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 , _sc_playback_latency (0)
71 , _sc_capture_latency (0)
72 , _signal_analysis_collected_nframes(0)
73 , _signal_analysis_collect_nframes_max(0)
78 , _maps_from_state (false)
80 /* the first is the master */
84 create_automatable_parameters ();
85 const ChanCount& sc (sidechain_input_pins ());
86 if (sc.n_audio () > 0) {
87 add_sidechain (sc.n_audio ());
92 PluginInsert::~PluginInsert ()
97 PluginInsert::set_strict_io (bool b)
99 bool changed = _strict_io != b;
102 PluginConfigChanged (); /* EMIT SIGNAL */
107 PluginInsert::set_count (uint32_t num)
109 bool require_state = !_plugins.empty();
111 if (require_state && num > 1 && plugin (0)->get_info ()->type == ARDOUR::AudioUnit) {
112 // we don't allow to replicate AUs
116 /* this is a bad idea.... we shouldn't do this while active.
117 * only a route holding their redirect_lock should be calling this
122 } else if (num > _plugins.size()) {
123 uint32_t diff = num - _plugins.size();
125 for (uint32_t n = 0; n < diff; ++n) {
126 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
130 XMLNode& state = _plugins[0]->get_state ();
131 p->set_state (state, Stateful::loading_state_version);
138 PluginConfigChanged (); /* EMIT SIGNAL */
140 } else if (num < _plugins.size()) {
141 uint32_t diff = _plugins.size() - num;
142 for (uint32_t n= 0; n < diff; ++n) {
145 PluginConfigChanged (); /* EMIT SIGNAL */
153 PluginInsert::set_sinks (const ChanCount& c)
156 /* no signal, change will only be visible after re-config */
160 PluginInsert::set_outputs (const ChanCount& c)
162 bool changed = (_custom_out != c) && _custom_cfg;
165 PluginConfigChanged (); /* EMIT SIGNAL */
170 PluginInsert::set_custom_cfg (bool b)
172 bool changed = _custom_cfg != b;
175 PluginConfigChanged (); /* EMIT SIGNAL */
180 PluginInsert::set_preset_out (const ChanCount& c)
182 bool changed = _preset_out != c;
184 if (changed && !_custom_cfg) {
185 PluginConfigChanged (); /* EMIT SIGNAL */
191 PluginInsert::add_sidechain (uint32_t n_audio)
193 // caller must hold process lock
197 std::ostringstream n;
199 n << "Sidechain " << Session::next_name_id ();
201 n << "TO BE RESET FROM XML";
203 SideChain *sc = new SideChain (_session, n.str ());
204 _sidechain = boost::shared_ptr<SideChain> (sc);
205 _sidechain->activate ();
206 for (uint32_t n = 0; n < n_audio; ++n) {
207 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
209 PluginConfigChanged (); /* EMIT SIGNAL */
214 PluginInsert::del_sidechain ()
220 _sc_playback_latency = 0;
221 _sc_capture_latency = 0;
222 PluginConfigChanged (); /* EMIT SIGNAL */
227 PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback)
230 (_sc_playback_latency != playback || _sc_capture_latency != capture)) {
231 _sc_capture_latency = capture;
232 _sc_playback_latency = playback;
233 LatencyRange pl; pl.min = pl.max = playback;
234 LatencyRange cl; cl.min = cl.max = capture;
235 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback));
236 PortSet& ps (_sidechain->input ()->ports ());
237 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
238 p->set_private_latency_range (pl, true);
239 p->set_private_latency_range (cl, false);
245 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
247 if (which.type() != PluginAutomation)
250 boost::shared_ptr<AutomationControl> c
251 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
254 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
259 PluginInsert::output_streams() const
261 assert (_configured);
262 return _configured_out;
266 PluginInsert::input_streams() const
268 assert (_configured);
269 return _configured_in;
273 PluginInsert::internal_streams() const
275 assert (_configured);
276 return _configured_internal;
280 PluginInsert::internal_output_streams() const
282 assert (!_plugins.empty());
284 PluginInfoPtr info = _plugins.front()->get_info();
286 if (info->reconfigurable_io()) {
287 ChanCount out = _plugins.front()->output_streams ();
288 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
291 ChanCount out = info->n_outputs;
292 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
293 out.set_audio (out.n_audio() * _plugins.size());
294 out.set_midi (out.n_midi() * _plugins.size());
300 PluginInsert::internal_input_streams() const
302 assert (!_plugins.empty());
306 PluginInfoPtr info = _plugins.front()->get_info();
308 if (info->reconfigurable_io()) {
309 in = _plugins.front()->input_streams();
314 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
316 if (_match.method == Split) {
318 /* we are splitting 1 processor input to multiple plugin inputs,
319 so we have a maximum of 1 stream of each type.
321 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
322 if (in.get (*t) > 1) {
328 } else if (_match.method == Hide) {
330 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
331 in.set (*t, in.get (*t) - _match.hide.get (*t));
337 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
338 in.set (*t, in.get (*t) * _plugins.size ());
346 PluginInsert::natural_output_streams() const
349 if (is_channelstrip ()) {
350 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
353 return _plugins[0]->get_info()->n_outputs;
357 PluginInsert::natural_input_streams() const
360 if (is_channelstrip ()) {
361 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
364 return _plugins[0]->get_info()->n_inputs;
368 PluginInsert::sidechain_input_pins() const
370 return _cached_sidechain_pins;
374 PluginInsert::has_no_inputs() const
376 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
380 PluginInsert::has_no_audio_inputs() const
382 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
386 PluginInsert::plugin_latency () const {
387 return _plugins.front()->signal_latency ();
391 PluginInsert::needs_midi_input() const
393 PluginInfoPtr pip = _plugins[0]->get_info();
394 if (pip->needs_midi_input ()) {
397 return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
401 PluginInsert::has_output_presets (ChanCount in, ChanCount out)
403 if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) {
404 // collect possible configurations, prefer given in/out
405 _plugins[0]->can_support_io_configuration (in, out);
408 PluginOutputConfiguration ppc (_plugins[0]->possible_output ());
410 if (ppc.size () == 0) {
413 if (!strict_io () && ppc.size () == 1) {
417 if (strict_io () && ppc.size () == 1) {
418 // "stereo" is currently preferred default for instruments
419 if (ppc.find (2) != ppc.end ()) {
423 if (!needs_midi_input ()) {
430 PluginInsert::create_automatable_parameters ()
432 assert (!_plugins.empty());
434 boost::shared_ptr<Plugin> plugin = _plugins.front();
435 set<Evoral::Parameter> a = _plugins.front()->automatable ();
437 for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
438 if (!plugin->parameter_is_control (i) || !plugin->parameter_is_input (i)) {
441 Evoral::Parameter param (PluginAutomation, 0, i);
443 ParameterDescriptor desc;
444 plugin->get_parameter_descriptor(i, desc);
446 const bool automatable = a.find(param) != a.end();
449 can_automate (param);
451 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
452 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
454 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
457 plugin->set_automation_control (i, c);
460 const Plugin::PropertyDescriptors& pdl (plugin->get_supported_properties ());
461 for (Plugin::PropertyDescriptors::const_iterator p = pdl.begin(); p != pdl.end(); ++p) {
462 Evoral::Parameter param (PluginPropertyAutomation, 0, p->first);
463 const ParameterDescriptor& desc = plugin->get_property_descriptor(param.id());
464 if (desc.datatype != Variant::NOTHING) {
465 boost::shared_ptr<AutomationList> list;
466 if (Variant::type_is_numeric(desc.datatype)) {
467 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
469 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
473 /** Called when something outside of this host has modified a plugin
474 * parameter. Responsible for propagating the change to two places:
476 * 1) anything listening to the Control itself
477 * 2) any replicated plugins that make up this PluginInsert.
479 * The PluginInsert is connected to the ParameterChangedExternally signal for
480 * the first (primary) plugin, and here broadcasts that change to any others.
482 * XXX We should probably drop this whole replication idea (Paul, October 2015)
483 * since it isn't used by sensible plugin APIs (AU, LV2).
486 PluginInsert::parameter_changed_externally (uint32_t which, float val)
488 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
490 /* First propagation: alter the underlying value of the control,
491 * without telling the plugin(s) that own/use it to set it.
498 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
501 pc->catch_up_with_external_value (val);
504 /* Second propagation: tell all plugins except the first to
505 update the value of this parameter. For sane plugin APIs,
506 there are no other plugins, so this is a no-op in those
510 Plugins::iterator i = _plugins.begin();
512 /* don't set the first plugin, just all the slaves */
514 if (i != _plugins.end()) {
516 for (; i != _plugins.end(); ++i) {
517 (*i)->set_parameter (which, val);
523 PluginInsert::set_block_size (pframes_t nframes)
526 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
527 if ((*i)->set_block_size (nframes) != 0) {
535 PluginInsert::activate ()
537 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
541 Processor::activate ();
545 PluginInsert::deactivate ()
547 Processor::deactivate ();
549 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
555 PluginInsert::flush ()
557 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
563 PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const
565 // TODO optimize: store "unconnected" in a fixed set.
566 // it only changes on reconfiguration.
567 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
568 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
570 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
571 mapped = true; // in-place Midi bypass
573 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
574 PinMappings::const_iterator i = out_map.find (pc);
575 if (i == out_map.end ()) {
578 const ChanMapping& outmap (i->second);
579 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
581 uint32_t idx = outmap.get (*t, o, &valid);
582 if (valid && idx == out) {
589 bufs.get (*t, out).silence (nframes, offset);
596 PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes, framecnt_t offset, bool with_auto)
598 // TODO: atomically copy maps & _no_inplace
599 PinMappings in_map (_in_map);
600 PinMappings out_map (_out_map);
601 ChanMapping thru_map (_thru_map);
602 if (_mapping_changed) { // ToDo use a counters, increment until match.
603 _no_inplace = check_inplace ();
604 _mapping_changed = false;
607 if (_latency_changed) {
608 /* delaylines are configured with the max possible latency (as reported by the plugin)
609 * so this won't allocate memory (unless the plugin lied about its max latency)
610 * It may still 'click' though, since the fixed delaylines are not de-clicked.
611 * Then again plugin-latency changes are not click-free to begin with.
613 * This is also worst case, there is currently no concept of per-stream latency.
615 * e.g. Two identical latent plugins:
616 * 1st plugin: process left (latent), bypass right.
617 * 2nd plugin: bypass left, process right (latent).
618 * -> currently this yields 2 times latency of the plugin,
620 _latency_changed = false;
621 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
624 if (_match.method == Split && !_no_inplace) {
625 // TODO: also use this optimization if one source-buffer
626 // feeds _all_ *connected* inputs.
627 // currently this is *first* buffer to all only --
628 // see PluginInsert::check_inplace
629 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
630 if (_configured_internal.get (*t) == 0) {
634 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
635 assert (valid && first_idx == 0); // check_inplace ensures this
636 /* copy the first stream's buffer contents to the others */
637 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
638 uint32_t idx = in_map[0].get (*t, i, &valid);
641 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
645 /* the copy operation produces a linear monotonic input map */
646 in_map[0] = ChanMapping (natural_input_streams ());
649 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
650 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
656 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
658 boost::shared_ptr<AutomationControl> c
659 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
661 if (c->list() && c->automation_playback()) {
664 const float val = c->list()->rt_safe_eval (start, valid);
667 /* This is the ONLY place where we are
669 * AutomationControl::set_value_unchecked(). We
670 * know that the control is in
671 * automation playback mode, so no
672 * check on writable() is required
673 * (which must be done in AutomationControl::set_value()
676 c->set_value_unchecked(val);
683 /* Calculate if, and how many frames we need to collect for analysis */
684 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
685 _signal_analysis_collected_nframes);
686 if (nframes < collect_signal_nframes) { // we might not get all frames now
687 collect_signal_nframes = nframes;
690 if (collect_signal_nframes > 0) {
692 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
693 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
694 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
696 _signal_analysis_inputs.set_count(input_streams());
698 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
699 _signal_analysis_inputs.get_audio(i).read_from (
701 collect_signal_nframes,
702 _signal_analysis_collected_nframes); // offset is for target buffer
707 if (is_channelstrip ()) {
708 if (_configured_in.n_audio() > 0) {
709 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
710 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
712 _plugins.front()->connect_and_run (bufs, start, end, speed, mb_in_map, mb_out_map, nframes, offset);
714 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
715 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
721 // TODO optimize -- build maps once.
723 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
724 ARDOUR::ChanMapping used_outputs;
726 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
728 /* build used-output map */
729 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
730 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
731 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
733 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
735 used_outputs.set (*t, out_idx, 1); // mark as used
740 /* copy thru data to outputs before processing in-place */
741 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
742 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
744 uint32_t in_idx = thru_map.get (*t, out, &valid);
745 uint32_t m = out + natural_input_streams ().get (*t);
747 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
748 used_outputs.set (*t, out, 1); // mark as used
750 used_outputs.get (*t, out, &valid);
752 /* the plugin is expected to write here, but may not :(
753 * (e.g. drumgizmo w/o kit loaded)
755 inplace_bufs.get (*t, m).silence (nframes);
762 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
764 ARDOUR::ChanMapping i_in_map (natural_input_streams());
765 ARDOUR::ChanMapping i_out_map (out_map[pc]);
766 ARDOUR::ChanCount mapped;
768 /* map inputs sequentially */
769 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
770 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
772 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
773 uint32_t m = mapped.get (*t);
775 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
777 inplace_bufs.get (*t, m).silence (nframes, offset);
779 mapped.set (*t, m + 1);
783 /* outputs are mapped to inplace_bufs after the inputs */
784 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
785 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
788 if ((*i)->connect_and_run (inplace_bufs, start, end, speed, i_in_map, i_out_map, nframes, offset)) {
793 /* all instances have completed, now copy data that was written
794 * and zero unconnected buffers */
795 ARDOUR::ChanMapping nonzero_out (used_outputs);
796 if (has_midi_bypass ()) {
797 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
799 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
800 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
802 used_outputs.get (*t, out, &valid);
804 nonzero_out.get (*t, out, &valid);
806 bufs.get (*t, out).silence (nframes, offset);
809 uint32_t m = out + natural_input_streams ().get (*t);
810 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
815 /* in-place processing */
817 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
818 if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) {
822 // now silence unconnected outputs
823 inplace_silence_unconnected (bufs, _out_map, nframes, offset);
826 if (collect_signal_nframes > 0) {
828 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
829 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
831 _signal_analysis_outputs.set_count(output_streams());
833 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
834 _signal_analysis_outputs.get_audio(i).read_from(
836 collect_signal_nframes,
837 _signal_analysis_collected_nframes); // offset is for target buffer
840 _signal_analysis_collected_nframes += collect_signal_nframes;
841 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
843 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
844 _signal_analysis_collect_nframes_max = 0;
845 _signal_analysis_collected_nframes = 0;
847 AnalysisDataGathered(&_signal_analysis_inputs,
848 &_signal_analysis_outputs);
854 PluginInsert::bypass (BufferSet& bufs, pframes_t nframes)
856 /* bypass the plugin(s) not the whole processor.
857 * -> use mappings just like connect_and_run
860 // TODO: atomically copy maps & _no_inplace
861 ChanMapping in_map (input_map ());
862 ChanMapping out_map (output_map ());
863 if (_mapping_changed) {
864 _no_inplace = check_inplace ();
865 _mapping_changed = false;
868 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
869 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
872 ChanMapping thru_map (_thru_map);
874 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
876 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
877 for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) {
878 inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0);
881 ARDOUR::ChanMapping used_outputs;
883 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
884 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
886 uint32_t in_idx = thru_map.get (*t, out, &valid);
888 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
889 used_outputs.set (*t, out, 1); // mark as used
893 // plugin no-op: assume every plugin has an internal identity map
894 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
895 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
897 uint32_t src_idx = out_map.get_src (*t, out, &valid);
901 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
905 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
906 used_outputs.set (*t, out, 1); // mark as used
909 // now silence all unused outputs
910 if (has_midi_bypass ()) {
911 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
913 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
914 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
916 used_outputs.get (*t, out, &valid);
918 bufs.get (*t, out).silence (nframes, 0);
923 if (_match.method == Split) {
924 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
925 if (_configured_internal.get (*t) == 0) {
928 // copy/feeds _all_ *connected* inputs, copy the first buffer
930 uint32_t first_idx = in_map.get (*t, 0, &valid);
931 assert (valid && first_idx == 0); // check_inplace ensures this
932 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
933 uint32_t idx = in_map.get (*t, i, &valid);
936 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0);
942 // apply output map and/or monotonic but not identity i/o mappings
943 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
944 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
946 uint32_t src_idx = out_map.get_src (*t, out, &valid);
948 bufs.get (*t, out).silence (nframes, 0);
951 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
953 bufs.get (*t, out).silence (nframes, 0);
956 if (in_idx != src_idx) {
957 bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0);
965 PluginInsert::silence (framecnt_t nframes, framepos_t start_frame)
971 _delaybuffers.flush ();
973 ChanMapping in_map (natural_input_streams ());
974 ChanMapping out_map (natural_output_streams ());
975 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
977 if (is_channelstrip ()) {
978 if (_configured_in.n_audio() > 0) {
979 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
983 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
984 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
989 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, double speed, pframes_t nframes, bool)
991 if (_pending_active) {
992 /* run as normal if we are active or moving from inactive to active */
995 // collect sidechain input for complete cycle (!)
996 // TODO we need delaylines here for latency compensation
997 _sidechain->run (bufs, start_frame, end_frame, speed, nframes, true);
1000 if (_session.transport_rolling() || _session.bounce_processing()) {
1001 automation_run (bufs, start_frame, end_frame, speed, nframes);
1003 connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, false);
1007 bypass (bufs, nframes);
1008 _delaybuffers.flush ();
1011 _active = _pending_active;
1013 /* we have no idea whether the plugin generated silence or not, so mark
1014 * all buffers appropriately.
1019 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes)
1021 Evoral::ControlEvent next_event (0, 0.0f);
1022 framecnt_t offset = 0;
1024 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1027 connect_and_run (bufs, start, end, speed, nframes, offset, false);
1031 if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1033 /* no events have a time within the relevant range */
1035 connect_and_run (bufs, start, end, speed, nframes, offset, true);
1041 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - start), (framecnt_t) nframes);
1043 connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed
1049 if (!find_next_event (start, end, next_event)) {
1054 /* cleanup anything that is left to do */
1057 connect_and_run (bufs, start, start + nframes, speed, nframes, offset, true);
1062 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1064 if (param.type() != PluginAutomation)
1067 if (_plugins.empty()) {
1068 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1070 abort(); /*NOTREACHED*/
1073 return _plugins[0]->default_value (param.id());
1078 PluginInsert::can_reset_all_parameters ()
1081 uint32_t params = 0;
1082 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1084 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1086 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1090 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1096 if (ac->automation_state() & Play) {
1101 return all && (params > 0);
1105 PluginInsert::reset_parameters_to_default ()
1109 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1111 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1113 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1117 const float dflt = _plugins[0]->default_value (cid);
1118 const float curr = _plugins[0]->get_parameter (cid);
1124 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1129 if (ac->automation_state() & Play) {
1134 ac->set_value (dflt, Controllable::NoGroup);
1139 boost::shared_ptr<Plugin>
1140 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1142 boost::shared_ptr<LadspaPlugin> lp;
1143 boost::shared_ptr<LuaProc> lua;
1145 boost::shared_ptr<LV2Plugin> lv2p;
1147 #ifdef WINDOWS_VST_SUPPORT
1148 boost::shared_ptr<WindowsVSTPlugin> vp;
1150 #ifdef LXVST_SUPPORT
1151 boost::shared_ptr<LXVSTPlugin> lxvp;
1153 #ifdef AUDIOUNIT_SUPPORT
1154 boost::shared_ptr<AUPlugin> ap;
1157 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1158 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1159 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1160 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1162 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1163 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1165 #ifdef WINDOWS_VST_SUPPORT
1166 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1167 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1169 #ifdef LXVST_SUPPORT
1170 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1171 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1173 #ifdef AUDIOUNIT_SUPPORT
1174 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1175 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1179 fatal << string_compose (_("programming error: %1"),
1180 X_("unknown plugin type in PluginInsert::plugin_factory"))
1182 abort(); /*NOTREACHED*/
1183 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1187 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1188 if (num < _in_map.size()) {
1189 bool changed = _in_map[num] != m;
1191 changed |= sanitize_maps ();
1193 PluginMapChanged (); /* EMIT SIGNAL */
1194 _mapping_changed = true;
1195 _session.set_dirty();
1201 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1202 if (num < _out_map.size()) {
1203 bool changed = _out_map[num] != m;
1205 changed |= sanitize_maps ();
1207 PluginMapChanged (); /* EMIT SIGNAL */
1208 _mapping_changed = true;
1209 _session.set_dirty();
1215 PluginInsert::set_thru_map (ChanMapping m) {
1216 bool changed = _thru_map != m;
1218 changed |= sanitize_maps ();
1220 PluginMapChanged (); /* EMIT SIGNAL */
1221 _mapping_changed = true;
1222 _session.set_dirty();
1227 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1228 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1230 if (_configured) { return false; }
1231 _configured_in = in;
1232 _configured_out = out;
1236 _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1241 PluginInsert::input_map () const
1245 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1246 ChanMapping m (i->second);
1247 const ChanMapping::Mappings& mp ((*i).second.mappings());
1248 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1249 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1250 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1258 PluginInsert::output_map () const
1262 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1263 ChanMapping m (i->second);
1264 const ChanMapping::Mappings& mp ((*i).second.mappings());
1265 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1266 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1267 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1271 if (has_midi_bypass ()) {
1272 rv.set (DataType::MIDI, 0, 0);
1279 PluginInsert::has_midi_bypass () const
1281 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1282 && natural_output_streams ().n_midi () == 0) {
1289 PluginInsert::has_midi_thru () const
1291 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1292 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1300 PluginInsert::is_channelstrip () const {
1301 return _plugins.front()->is_channelstrip();
1306 PluginInsert::check_inplace ()
1308 bool inplace_ok = !_plugins.front()->inplace_broken ();
1310 if (_thru_map.n_total () > 0) {
1311 // TODO once midi-bypass is part of the mapping, ignore it
1315 if (_match.method == Split && inplace_ok) {
1316 assert (get_count() == 1);
1317 assert (_in_map.size () == 1);
1318 if (!_out_map[0].is_monotonic ()) {
1321 if (_configured_internal != _configured_in) {
1322 /* no sidechain -- TODO we could allow this with
1323 * some more logic in PluginInsert::connect_and_run().
1325 * PluginInsert::reset_map() already maps it.
1330 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1331 if (_configured_internal.get (*t) == 0) {
1335 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1336 if (!valid || first_idx != 0) {
1337 // so far only allow to copy the *first* stream's buffer to others
1340 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1341 uint32_t idx = _in_map[0].get (*t, i, &valid);
1342 if (valid && idx != first_idx) {
1351 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1356 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1357 if (!_in_map[pc].is_monotonic ()) {
1360 if (!_out_map[pc].is_monotonic ()) {
1366 /* check if every output is fed by the corresponding input
1368 * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2
1369 * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1)
1371 * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
1373 ChanMapping in_map (input_map ());
1374 const ChanMapping::Mappings out_m (output_map ().mappings ());
1375 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1376 for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1377 /* src-pin: c->first, out-port: c->second */
1379 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1380 if (valid && in_port != c->second) {
1388 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1389 return !inplace_ok; // no-inplace
1393 PluginInsert::sanitize_maps ()
1395 bool changed = false;
1396 /* strip dead wood */
1397 PinMappings new_ins;
1398 PinMappings new_outs;
1399 ChanMapping new_thru;
1401 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1403 ChanMapping new_out;
1404 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1405 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1407 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1408 if (valid && idx < _configured_internal.get (*t)) {
1409 new_in.set (*t, i, idx);
1412 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1414 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1415 if (valid && idx < _configured_out.get (*t)) {
1416 new_out.set (*t, o, idx);
1420 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1423 new_ins[pc] = new_in;
1424 new_outs[pc] = new_out;
1427 /* prevent dup output assignments */
1428 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1429 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1430 bool mapped = false;
1431 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1433 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1434 if (valid && mapped) {
1435 new_outs[pc].unset (*t, idx);
1443 /* remove excess thru */
1444 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1445 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1447 uint32_t idx = _thru_map.get (*t, o, &valid);
1448 if (valid && idx < _configured_internal.get (*t)) {
1449 new_thru.set (*t, o, idx);
1454 /* prevent out + thru, existing plugin outputs override thru */
1455 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1456 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1457 bool mapped = false;
1459 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1460 new_outs[pc].get_src (*t, o, &mapped);
1461 if (mapped) { break; }
1463 if (!mapped) { continue; }
1464 uint32_t idx = new_thru.get (*t, o, &valid);
1466 new_thru.unset (*t, idx);
1471 if (has_midi_bypass ()) {
1472 // TODO: include midi-bypass in the thru set,
1473 // remove dedicated handling.
1474 new_thru.unset (DataType::MIDI, 0);
1477 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1481 _out_map = new_outs;
1482 _thru_map = new_thru;
1488 PluginInsert::reset_map (bool emit)
1490 const PinMappings old_in (_in_map);
1491 const PinMappings old_out (_out_map);
1495 _thru_map = ChanMapping ();
1497 /* build input map */
1498 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1499 uint32_t sc = 0; // side-chain round-robin (all instances)
1501 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1502 const uint32_t nis = natural_input_streams ().get(*t);
1503 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1505 /* SC inputs are last in the plugin-insert.. */
1506 const uint32_t sc_start = _configured_in.get (*t);
1507 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1508 /* ...but may not be at the end of the plugin ports.
1509 * in case the side-chain is not the last port, shift connections back.
1510 * and connect to side-chain
1513 uint32_t ic = 0; // split inputs
1514 const uint32_t cend = _configured_in.get (*t);
1516 for (uint32_t in = 0; in < nis; ++in) {
1517 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1518 if (iod.is_sidechain) {
1519 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1520 if (sc_len > 0) {// side-chain may be hidden
1521 _in_map[pc].set (*t, in, sc_start + sc);
1522 sc = (sc + 1) % sc_len;
1526 if (_match.method == Split) {
1527 if (cend == 0) { continue; }
1528 if (_strict_io && ic + stride * pc >= cend) {
1531 /* connect *no* sidechain sinks in round-robin fashion */
1532 _in_map[pc].set (*t, in, ic + stride * pc);
1533 if (_strict_io && (ic + 1) == cend) {
1536 ic = (ic + 1) % cend;
1538 uint32_t s = in - shift;
1539 if (stride * pc + s < cend) {
1540 _in_map[pc].set (*t, in, s + stride * pc);
1548 /* build output map */
1550 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1551 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1552 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1553 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1558 if (old_in == _in_map && old_out == _out_map) {
1562 PluginMapChanged (); /* EMIT SIGNAL */
1563 _mapping_changed = true;
1564 _session.set_dirty();
1570 PluginInsert::configure_io (ChanCount in, ChanCount out)
1572 Match old_match = _match;
1574 ChanCount old_internal;
1578 old_pins = natural_input_streams();
1579 old_in = _configured_in;
1580 old_out = _configured_out;
1581 old_internal = _configured_internal;
1583 _configured_in = in;
1584 _configured_internal = in;
1585 _configured_out = out;
1588 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1589 * (currently _sidechain->configure_io always succeeds
1590 * since Processor::configure_io() succeeds)
1592 if (!_sidechain->configure_io (in, out)) {
1593 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1596 _configured_internal += _sidechain->input()->n_ports();
1598 // include (static_cast<Route*>owner())->name() ??
1599 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1602 /* get plugin configuration */
1603 _match = private_can_support_io_configuration (in, out);
1605 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1607 DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
1608 DEBUG_STR_APPEND(a, _match);
1609 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1613 /* set the matching method and number of plugins that we will use to meet this configuration */
1614 if (set_count (_match.plugins) == false) {
1615 PluginIoReConfigure (); /* EMIT SIGNAL */
1616 _configured = false;
1620 /* configure plugins */
1621 switch (_match.method) {
1624 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1625 PluginIoReConfigure (); /* EMIT SIGNAL */
1626 _configured = false;
1632 ChanCount din (_configured_internal);
1633 ChanCount dout (din); // hint
1635 if (_custom_sinks.n_total () > 0) {
1636 din = _custom_sinks;
1639 } else if (_preset_out.n_audio () > 0) {
1640 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1641 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1642 dout.set (DataType::AUDIO, 2);
1644 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1646 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1647 bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1649 if (useins.n_audio() == 0) {
1652 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1654 if (_plugins.front()->configure_io (useins, dout) == false) {
1655 PluginIoReConfigure (); /* EMIT SIGNAL */
1656 _configured = false;
1660 _custom_sinks = din;
1665 if (_plugins.front()->configure_io (in, out) == false) {
1666 PluginIoReConfigure (); /* EMIT SIGNAL */
1667 _configured = false;
1673 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: cfg:%2 state:%3 chn-in:%4 chn-out:%5 inpin:%6 match:%7 cust:%8 size-in:%9 size-out:%10\n",
1675 _configured ? "Y" : "N",
1676 _maps_from_state ? "Y" : "N",
1677 old_in == in ? "==" : "!=",
1678 old_out == out ? "==" : "!=",
1679 old_pins == natural_input_streams () ? "==" : "!=",
1680 old_match.method == _match.method ? "==" : "!=",
1681 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1682 _in_map.size() == get_count () ? "==" : "!=",
1683 _out_map.size() == get_count () ? "==" : "!="
1686 bool mapping_changed = false;
1687 if (old_in == in && old_out == out
1689 && old_pins == natural_input_streams ()
1690 && old_match.method == _match.method
1691 && old_match.custom_cfg == _match.custom_cfg
1692 && _in_map.size() == _out_map.size()
1693 && _in_map.size() == get_count ()
1695 assert (_maps_from_state == false);
1696 /* If the configuration has not changed, keep the mapping */
1697 mapping_changed = sanitize_maps ();
1698 } else if (_match.custom_cfg && _configured) {
1699 assert (_maps_from_state == false);
1700 /* don't touch the map in manual mode */
1701 mapping_changed = sanitize_maps ();
1704 if (is_channelstrip ()) {
1705 /* fake channel map - for wire display */
1708 _thru_map = ChanMapping ();
1709 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1710 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1711 /* set "thru" map for in-place forward of audio */
1712 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1713 _thru_map.set (DataType::AUDIO, i, i);
1715 /* and midi (after implicit 1st channel bypass) */
1716 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1717 _thru_map.set (DataType::MIDI, i, i);
1721 if (_maps_from_state && old_in == in && old_out == out) {
1722 mapping_changed = true;
1725 /* generate a new mapping */
1726 mapping_changed = reset_map (false);
1728 _maps_from_state = false;
1731 if (mapping_changed) {
1732 PluginMapChanged (); /* EMIT SIGNAL */
1735 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1738 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1739 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1741 DEBUG_STR_APPEND(a, "----><----\n");
1743 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1744 DEBUG_STR_APPEND(a, " * Inputs:\n");
1745 DEBUG_STR_APPEND(a, _in_map[pc]);
1746 DEBUG_STR_APPEND(a, " * Outputs:\n");
1747 DEBUG_STR_APPEND(a, _out_map[pc]);
1749 DEBUG_STR_APPEND(a, " * Thru:\n");
1750 DEBUG_STR_APPEND(a, _thru_map);
1751 DEBUG_STR_APPEND(a, "-------->>--------\n");
1752 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1757 _no_inplace = check_inplace ();
1758 _mapping_changed = false;
1760 /* only the "noinplace_buffers" thread buffers need to be this large,
1761 * this can be optimized. other buffers are fine with
1762 * ChanCount::max (natural_input_streams (), natural_output_streams())
1763 * and route.cc's max (configured_in, configured_out)
1765 * no-inplace copies "thru" outputs (to emulate in-place) for
1766 * all outputs (to prevent overwrite) into a temporary space
1767 * which also holds input buffers (in case the plugin does process
1768 * in-place and overwrites those).
1770 * this buffers need to be at least as
1771 * natural_input_streams () + possible outputs.
1773 * sidechain inputs add a constraint on the input:
1774 * configured input + sidechain (=_configured_internal)
1776 * NB. this also satisfies
1777 * max (natural_input_streams(), natural_output_streams())
1778 * which is needed for silence runs
1780 _required_buffers = ChanCount::max (_configured_internal,
1781 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1783 if (old_in != in || old_out != out || old_internal != _configured_internal
1784 || old_pins != natural_input_streams ()
1785 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1787 PluginIoReConfigure (); /* EMIT SIGNAL */
1790 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1791 _latency_changed = true;
1793 // we don't know the analysis window size, so we must work with the
1794 // current buffer size here. each request for data fills in these
1795 // buffers and the analyser makes sure it gets enough data for the
1797 session().ensure_buffer_set (_signal_analysis_inputs, in);
1798 _signal_analysis_inputs.set_count (in);
1800 session().ensure_buffer_set (_signal_analysis_outputs, out);
1801 _signal_analysis_outputs.set_count (out);
1803 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1806 return Processor::configure_io (in, out);
1809 /** Decide whether this PluginInsert can support a given IO configuration.
1810 * To do this, we run through a set of possible solutions in rough order of
1813 * @param in Required input channel count.
1814 * @param out Filled in with the output channel count if we return true.
1815 * @return true if the given IO configuration can be supported.
1818 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1821 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1823 return private_can_support_io_configuration (in, out).method != Impossible;
1827 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1829 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1830 // preseed hint (for variable i/o)
1831 out.set (DataType::AUDIO, _preset_out.n_audio ());
1834 Match rv = internal_can_support_io_configuration (in, out);
1836 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1837 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
1838 out.set (DataType::AUDIO, _preset_out.n_audio ());
1843 /** A private version of can_support_io_configuration which returns the method
1844 * by which the configuration can be matched, rather than just whether or not
1848 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1850 if (_plugins.empty()) {
1855 if (is_channelstrip ()) {
1857 return Match (ExactMatch, 1);
1861 /* if a user specified a custom cfg, so be it. */
1863 PluginInfoPtr info = _plugins.front()->get_info();
1865 if (info->reconfigurable_io()) {
1866 return Match (Delegate, 1, _strict_io, true);
1868 return Match (ExactMatch, get_count(), _strict_io, true);
1872 /* try automatic configuration */
1873 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1875 PluginInfoPtr info = _plugins.front()->get_info();
1876 ChanCount inputs = info->n_inputs;
1877 ChanCount outputs = info->n_outputs;
1879 /* handle case strict-i/o */
1880 if (_strict_io && m.method != Impossible) {
1883 /* special case MIDI instruments */
1884 if (needs_midi_input ()) {
1885 // output = midi-bypass + at most master-out channels.
1886 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1887 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1888 out = ChanCount::min (out, max_out);
1889 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
1895 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1896 /* replicate processor to match output count (generators and such)
1897 * at least enough to feed every output port. */
1898 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1899 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1900 uint32_t nout = outputs.get (*t);
1901 if (nout == 0 || inx.get(*t) == 0) { continue; }
1902 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1905 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
1906 return Match (Replicate, f, _strict_io);
1917 if (m.method != Impossible) {
1921 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1923 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
1925 if (info->reconfigurable_io()) {
1928 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1929 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1930 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
1932 // houston, we have a problem.
1933 return Match (Impossible, 0);
1936 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
1937 return Match (Delegate, 1, _strict_io);
1940 ChanCount midi_bypass;
1941 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1942 midi_bypass.set (DataType::MIDI, 1);
1945 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1947 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1948 uint32_t nin = ns_inputs.get (*t);
1949 uint32_t nout = outputs.get (*t);
1950 if (nin == 0 || inx.get(*t) == 0) { continue; }
1951 // prefer floor() so the count won't overly increase IFF (nin < nout)
1952 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1954 if (f > 0 && outputs * f >= _configured_out) {
1955 out = outputs * f + midi_bypass;
1956 return Match (Replicate, f, _strict_io);
1959 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1961 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1962 uint32_t nin = ns_inputs.get (*t);
1963 if (nin == 0 || inx.get(*t) == 0) { continue; }
1964 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1967 out = outputs * f + midi_bypass;
1968 return Match (Replicate, f, _strict_io);
1971 // add at least as many plugins needed to connect all inputs
1973 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1974 uint32_t nin = inputs.get (*t);
1975 if (nin == 0 || inx.get(*t) == 0) { continue; }
1976 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1978 out = outputs * f + midi_bypass;
1979 return Match (Replicate, f, _strict_io);
1982 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1984 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1986 if (_plugins.empty()) {
1990 PluginInfoPtr info = _plugins.front()->get_info();
1991 ChanCount in; in += inx;
1992 ChanCount midi_bypass;
1994 if (info->reconfigurable_io()) {
1995 /* Plugin has flexible I/O, so delegate to it
1996 * pre-seed outputs, plugin tries closest match
1999 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2000 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2001 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
2003 return Match (Impossible, 0);
2006 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2007 return Match (Delegate, 1);
2010 ChanCount inputs = info->n_inputs;
2011 ChanCount outputs = info->n_outputs;
2012 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2014 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2015 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
2016 midi_bypass.set (DataType::MIDI, 1);
2018 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
2019 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
2020 in.set(DataType::MIDI, 0);
2023 // add internally provided sidechain ports
2024 ChanCount insc = in + sidechain_input_ports ();
2026 bool no_inputs = true;
2027 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2028 if (inputs.get (*t) != 0) {
2035 /* no inputs so we can take any input configuration since we throw it away */
2036 out = outputs + midi_bypass;
2037 return Match (NoInputs, 1);
2040 /* Plugin inputs match requested inputs + side-chain-ports exactly */
2041 if (inputs == insc) {
2042 out = outputs + midi_bypass;
2043 return Match (ExactMatch, 1);
2046 /* Plugin inputs matches without side-chain-pins */
2047 if (ns_inputs == in) {
2048 out = outputs + midi_bypass;
2049 return Match (ExactMatch, 1);
2052 /* We may be able to run more than one copy of the plugin within this insert
2053 to cope with the insert having more inputs than the plugin.
2054 We allow replication only for plugins with either zero or 1 inputs and outputs
2055 for every valid data type.
2059 bool can_replicate = true;
2060 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
2062 // ignore side-chains
2063 uint32_t nin = ns_inputs.get (*t);
2065 // No inputs of this type
2066 if (nin == 0 && in.get(*t) == 0) {
2070 if (nin != 1 || outputs.get (*t) != 1) {
2071 can_replicate = false;
2075 // Potential factor not set yet
2077 f = in.get(*t) / nin;
2080 // Factor for this type does not match another type, can not replicate
2081 if (f != (in.get(*t) / nin)) {
2082 can_replicate = false;
2087 if (can_replicate && f > 0) {
2088 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2089 out.set (*t, outputs.get(*t) * f);
2092 return Match (Replicate, f);
2095 /* If the processor has exactly one input of a given type, and
2096 the plugin has more, we can feed the single processor input
2097 to some or all of the plugin inputs. This is rather
2098 special-case-y, but the 1-to-many case is by far the
2099 simplest. How do I split thy 2 processor inputs to 3
2100 plugin inputs? Let me count the ways ...
2103 bool can_split = true;
2104 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2106 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2107 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2109 if (!can_split_type && !nothing_to_do_for_type) {
2115 out = outputs + midi_bypass;
2116 return Match (Split, 1);
2119 /* If the plugin has more inputs than we want, we can `hide' some of them
2120 by feeding them silence.
2123 bool could_hide = false;
2124 bool cannot_hide = false;
2125 ChanCount hide_channels;
2127 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2128 if (inputs.get(*t) > in.get(*t)) {
2129 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2130 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2132 } else if (inputs.get(*t) < in.get(*t)) {
2133 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2138 if (could_hide && !cannot_hide) {
2139 out = outputs + midi_bypass;
2140 return Match (Hide, 1, false, false, hide_channels);
2143 return Match (Impossible, 0);
2148 PluginInsert::get_state ()
2150 return state (true);
2154 PluginInsert::state (bool full)
2156 XMLNode& node = Processor::state (full);
2158 node.add_property("type", _plugins[0]->state_node_name());
2159 node.add_property("unique-id", _plugins[0]->unique_id());
2160 node.add_property("count", string_compose("%1", _plugins.size()));
2162 /* remember actual i/o configuration (for later placeholder
2163 * in case the plugin goes missing) */
2164 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2165 node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2166 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2167 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2169 /* save custom i/o config */
2170 node.add_property("custom", _custom_cfg ? "yes" : "no");
2171 for (uint32_t pc = 0; pc < get_count(); ++pc) {
2173 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2174 node.add_child_nocopy (* _in_map[pc].state (tmp));
2175 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2176 node.add_child_nocopy (* _out_map[pc].state (tmp));
2178 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2181 node.add_child_nocopy (_sidechain->state (full));
2184 _plugins[0]->set_insert_id(this->id());
2185 node.add_child_nocopy (_plugins[0]->get_state());
2187 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2188 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2190 node.add_child_nocopy (ac->get_state());
2198 PluginInsert::set_control_ids (const XMLNode& node, int version)
2200 const XMLNodeList& nlist = node.children();
2201 XMLNodeConstIterator iter;
2202 set<Evoral::Parameter>::const_iterator p;
2204 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2205 if ((*iter)->name() == Controllable::xml_node_name) {
2206 XMLProperty const * prop;
2208 uint32_t p = (uint32_t)-1;
2210 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
2211 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2213 p = lv2plugin->port_index(prop->value().c_str());
2217 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
2218 p = atoi (prop->value());
2221 if (p != (uint32_t)-1) {
2223 /* this may create the new controllable */
2225 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2227 #ifndef NO_PLUGIN_STATE
2231 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2233 ac->set_state (**iter, version);
2242 PluginInsert::set_state(const XMLNode& node, int version)
2244 XMLNodeList nlist = node.children();
2245 XMLNodeIterator niter;
2246 XMLPropertyList plist;
2247 XMLProperty const * prop;
2248 ARDOUR::PluginType type;
2250 if ((prop = node.property ("type")) == 0) {
2251 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2255 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2256 type = ARDOUR::LADSPA;
2257 } else if (prop->value() == X_("lv2")) {
2259 } else if (prop->value() == X_("windows-vst")) {
2260 type = ARDOUR::Windows_VST;
2261 } else if (prop->value() == X_("lxvst")) {
2262 type = ARDOUR::LXVST;
2263 } else if (prop->value() == X_("audiounit")) {
2264 type = ARDOUR::AudioUnit;
2265 } else if (prop->value() == X_("luaproc")) {
2268 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2274 prop = node.property ("unique-id");
2277 #ifdef WINDOWS_VST_SUPPORT
2278 /* older sessions contain VST plugins with only an "id" field.
2281 if (type == ARDOUR::Windows_VST) {
2282 prop = node.property ("id");
2286 #ifdef LXVST_SUPPORT
2287 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2289 if (type == ARDOUR::LXVST) {
2290 prop = node.property ("id");
2296 error << _("Plugin has no unique ID field") << endmsg;
2301 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2303 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2304 * allow to move sessions windows <> linux */
2305 #ifdef LXVST_SUPPORT
2306 if (plugin == 0 && type == ARDOUR::Windows_VST) {
2307 type = ARDOUR::LXVST;
2308 plugin = find_plugin (_session, prop->value(), type);
2312 #ifdef WINDOWS_VST_SUPPORT
2313 if (plugin == 0 && type == ARDOUR::LXVST) {
2314 type = ARDOUR::Windows_VST;
2315 plugin = find_plugin (_session, prop->value(), type);
2319 if (plugin == 0 && type == ARDOUR::Lua) {
2320 /* unique ID (sha1 of script) was not found,
2321 * load the plugin from the serialized version in the
2322 * session-file instead.
2324 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2325 XMLNode *ls = node.child (lp->state_node_name().c_str());
2327 lp->set_script_from_state (*ls);
2333 error << string_compose(
2334 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2335 "Perhaps it was removed or moved since it was last used."),
2341 // The name of the PluginInsert comes from the plugin, nothing else
2342 _name = plugin->get_info()->name;
2346 // Processor::set_state() will set this, but too late
2347 // for it to be available when setting up plugin
2348 // state. We can't call Processor::set_state() until
2349 // the plugins themselves are created and added.
2353 if (_plugins.empty()) {
2354 /* if we are adding the first plugin, we will need to set
2355 up automatable controls.
2357 add_plugin (plugin);
2358 create_automatable_parameters ();
2359 set_control_ids (node, version);
2362 if ((prop = node.property ("count")) != 0) {
2363 sscanf (prop->value().c_str(), "%u", &count);
2366 if (_plugins.size() != count) {
2367 for (uint32_t n = 1; n < count; ++n) {
2368 add_plugin (plugin_factory (plugin));
2372 Processor::set_state (node, version);
2374 PBD::ID new_id = this->id();
2375 PBD::ID old_id = this->id();
2377 if ((prop = node.property ("id")) != 0) {
2378 old_id = prop->value ();
2381 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2383 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2384 and set all plugins to the same state.
2387 if ((*niter)->name() == plugin->state_node_name()) {
2389 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2390 /* Plugin state can include external files which are named after the ID.
2392 * If regenerate_xml_or_string_ids() is set, the ID will already have
2393 * been changed, so we need to use the old ID from the XML to load the
2394 * state and then update the ID.
2396 * When copying a plugin-state, route_ui takes care of of updating the ID,
2397 * but we need to call set_insert_id() to clear the cached plugin-state
2398 * and force a change.
2400 if (!regenerate_xml_or_string_ids ()) {
2401 (*i)->set_insert_id (new_id);
2403 (*i)->set_insert_id (old_id);
2406 (*i)->set_state (**niter, version);
2408 if (regenerate_xml_or_string_ids ()) {
2409 (*i)->set_insert_id (new_id);
2417 if (version < 3000) {
2419 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2420 this is all handled by Automatable
2423 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2424 if ((*niter)->name() == "Redirect") {
2425 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2426 Processor::set_state (**niter, version);
2431 set_parameter_state_2X (node, version);
2434 if ((prop = node.property (X_("custom"))) != 0) {
2435 _custom_cfg = string_is_affirmative (prop->value());
2438 uint32_t in_maps = 0;
2439 uint32_t out_maps = 0;
2440 XMLNodeList kids = node.children ();
2441 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2442 if ((*i)->name() == X_("ConfiguredInput")) {
2443 _configured_in = ChanCount(**i);
2445 if ((*i)->name() == X_("CustomSinks")) {
2446 _custom_sinks = ChanCount(**i);
2448 if ((*i)->name() == X_("ConfiguredOutput")) {
2449 _custom_out = ChanCount(**i);
2450 _configured_out = ChanCount(**i);
2452 if ((*i)->name() == X_("PresetOutput")) {
2453 _preset_out = ChanCount(**i);
2455 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2456 long pc = atol (&((*i)->name().c_str()[9]));
2457 if (pc >= 0 && pc <= (long) get_count()) {
2458 _in_map[pc] = ChanMapping (**i);
2462 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2463 long pc = atol (&((*i)->name().c_str()[10]));
2464 if (pc >= 0 && pc <= (long) get_count()) {
2465 _out_map[pc] = ChanMapping (**i);
2469 if ((*i)->name () == "ThruMap") {
2470 _thru_map = ChanMapping (**i);
2473 // sidechain is a Processor (IO)
2474 if ((*i)->name () == Processor::state_node_name) {
2478 _sidechain->set_state (**i, version);
2482 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2483 _maps_from_state = true;
2486 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2490 (*i)->deactivate ();
2494 PluginConfigChanged (); /* EMIT SIGNAL */
2499 PluginInsert::update_id (PBD::ID id)
2502 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2503 (*i)->set_insert_id (id);
2508 PluginInsert::set_state_dir (const std::string& d)
2510 // state() only saves the state of the first plugin
2511 _plugins[0]->set_state_dir (d);
2515 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2517 XMLNodeList nlist = node.children();
2518 XMLNodeIterator niter;
2520 /* look for port automation node */
2522 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2524 if ((*niter)->name() != port_automation_node_name) {
2529 XMLProperty const * cprop;
2530 XMLNodeConstIterator iter;
2535 cnodes = (*niter)->children ("port");
2537 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2541 if ((cprop = child->property("number")) != 0) {
2542 port = cprop->value().c_str();
2544 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2548 sscanf (port, "%" PRIu32, &port_id);
2550 if (port_id >= _plugins[0]->parameter_count()) {
2551 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2555 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2556 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2558 if (c && c->alist()) {
2559 if (!child->children().empty()) {
2560 c->alist()->set_state (*child->children().front(), version);
2562 /* In some cases 2.X saves lists with min_yval and max_yval
2563 being FLT_MIN and FLT_MAX respectively. This causes problems
2564 in A3 because these min/max values are used to compute
2565 where GUI control points should be drawn. If we see such
2566 values, `correct' them to the min/max of the appropriate
2570 float min_y = c->alist()->get_min_y ();
2571 float max_y = c->alist()->get_max_y ();
2573 ParameterDescriptor desc;
2574 _plugins.front()->get_parameter_descriptor (port_id, desc);
2576 if (min_y == FLT_MIN) {
2580 if (max_y == FLT_MAX) {
2584 c->alist()->set_yrange (min_y, max_y);
2587 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2599 PluginInsert::describe_parameter (Evoral::Parameter param)
2601 if (param.type() == PluginAutomation) {
2602 return _plugins[0]->describe_parameter (param);
2603 } else if (param.type() == PluginPropertyAutomation) {
2604 boost::shared_ptr<AutomationControl> c(automation_control(param));
2605 if (c && !c->desc().label.empty()) {
2606 return c->desc().label;
2609 return Automatable::describe_parameter(param);
2613 PluginInsert::signal_latency() const
2615 if (_user_latency) {
2616 return _user_latency;
2619 return _plugins[0]->signal_latency ();
2623 PluginInsert::type ()
2625 return plugin()->get_info()->type;
2628 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2629 const Evoral::Parameter& param,
2630 const ParameterDescriptor& desc,
2631 boost::shared_ptr<AutomationList> list)
2632 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2636 alist()->reset_default (desc.normal);
2638 list->set_interpolation(Evoral::ControlList::Discrete);
2643 /** @param val `user' value */
2646 PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2648 /* FIXME: probably should be taking out some lock here.. */
2650 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2651 (*i)->set_parameter (_list->parameter().id(), user_val);
2654 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2656 iasp->set_parameter (_list->parameter().id(), user_val);
2659 AutomationControl::actually_set_value (user_val, group_override);
2663 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2665 AutomationControl::actually_set_value (user_val, Controllable::NoGroup);
2669 PluginInsert::PluginControl::get_state ()
2673 XMLNode& node (AutomationControl::get_state());
2674 ss << parameter().id();
2675 node.add_property (X_("parameter"), ss.str());
2677 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2679 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2686 /** @return `user' val */
2688 PluginInsert::PluginControl::get_value () const
2690 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2696 return plugin->get_parameter (_list->parameter().id());
2699 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2700 const Evoral::Parameter& param,
2701 const ParameterDescriptor& desc,
2702 boost::shared_ptr<AutomationList> list)
2703 : AutomationControl (p->session(), param, desc, list)
2707 alist()->set_yrange (desc.lower, desc.upper);
2708 alist()->reset_default (desc.normal);
2713 PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd)
2715 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2716 This is lossy, but better than nothing until Ardour's automation system
2717 can handle various datatypes all the way down. */
2718 const Variant value(_desc.datatype, user_val);
2719 if (value.type() == Variant::NOTHING) {
2720 error << "set_value(double) called for non-numeric property" << endmsg;
2724 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2725 (*i)->set_property(_list->parameter().id(), value);
2730 AutomationControl::actually_set_value (user_val, gcd);
2734 PluginInsert::PluginPropertyControl::get_state ()
2738 XMLNode& node (AutomationControl::get_state());
2739 ss << parameter().id();
2740 node.add_property (X_("property"), ss.str());
2741 node.remove_property (X_("value"));
2747 PluginInsert::PluginPropertyControl::get_value () const
2749 return _value.to_double();
2752 boost::shared_ptr<Plugin>
2753 PluginInsert::get_impulse_analysis_plugin()
2755 boost::shared_ptr<Plugin> ret;
2756 if (_impulseAnalysisPlugin.expired()) {
2757 // LV2 in particular uses various _session params
2758 // during init() -- most notably block_size..
2760 ret = plugin_factory(_plugins[0]);
2761 ret->configure_io (internal_input_streams (), internal_output_streams ());
2762 _impulseAnalysisPlugin = ret;
2764 ret = _impulseAnalysisPlugin.lock();
2771 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2773 // called from outside the audio thread, so this should be safe
2774 // only do audio as analysis is (currently) only for audio plugins
2775 _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes);
2776 _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
2778 _signal_analysis_collected_nframes = 0;
2779 _signal_analysis_collect_nframes_max = nframes;
2782 /** Add a plugin to our list */
2784 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2786 plugin->set_insert_id (this->id());
2788 if (_plugins.empty()) {
2789 /* first (and probably only) plugin instance - connect to relevant signals */
2791 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2792 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2793 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2794 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2795 _custom_sinks = plugin->get_info()->n_inputs;
2796 // cache sidechain port count
2797 _cached_sidechain_pins.reset ();
2798 const ChanCount& nis (plugin->get_info()->n_inputs);
2799 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2800 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2801 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2802 if (iod.is_sidechain) {
2803 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2808 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2809 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2811 vst->set_insert (this, _plugins.size ());
2814 _plugins.push_back (plugin);
2818 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
2821 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2822 if (! (*i)->load_preset (pr)) {
2830 PluginInsert::realtime_handle_transport_stopped ()
2832 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2833 (*i)->realtime_handle_transport_stopped ();
2838 PluginInsert::realtime_locate ()
2840 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2841 (*i)->realtime_locate ();
2846 PluginInsert::monitoring_changed ()
2848 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2849 (*i)->monitoring_changed ();
2854 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2856 // this is called in RT context, LatencyChanged is emitted after run()
2857 _latency_changed = true;
2861 PluginInsert::start_touch (uint32_t param_id)
2863 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2865 ac->start_touch (session().audible_frame());
2870 PluginInsert::end_touch (uint32_t param_id)
2872 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2874 ac->stop_touch (true, session().audible_frame());
2878 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2881 case PluginInsert::Impossible: o << "Impossible"; break;
2882 case PluginInsert::Delegate: o << "Delegate"; break;
2883 case PluginInsert::NoInputs: o << "NoInputs"; break;
2884 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2885 case PluginInsert::Replicate: o << "Replicate"; break;
2886 case PluginInsert::Split: o << "Split"; break;
2887 case PluginInsert::Hide: o << "Hide"; break;
2889 o << " cnt: " << m.plugins
2890 << (m.strict_io ? " strict-io" : "")
2891 << (m.custom_cfg ? " custom-cfg" : "");
2892 if (m.method == PluginInsert::Hide) {
2893 o << " hide: " << m.hide;