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 , _plugin_signal_latency (0)
73 , _signal_analysis_collected_nframes(0)
74 , _signal_analysis_collect_nframes_max(0)
79 , _maps_from_state (false)
80 , _bypass_port (UINT32_MAX)
82 /* the first is the master */
86 create_automatable_parameters ();
87 const ChanCount& sc (sidechain_input_pins ());
88 if (sc.n_audio () > 0) {
89 add_sidechain (sc.n_audio ());
94 PluginInsert::~PluginInsert ()
99 PluginInsert::set_strict_io (bool b)
101 bool changed = _strict_io != b;
104 PluginConfigChanged (); /* EMIT SIGNAL */
109 PluginInsert::set_count (uint32_t num)
111 bool require_state = !_plugins.empty();
113 if (require_state && num > 1 && plugin (0)->get_info ()->type == ARDOUR::AudioUnit) {
114 // we don't allow to replicate AUs
118 /* this is a bad idea.... we shouldn't do this while active.
119 * only a route holding their redirect_lock should be calling this
124 } else if (num > _plugins.size()) {
125 uint32_t diff = num - _plugins.size();
127 for (uint32_t n = 0; n < diff; ++n) {
128 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
132 XMLNode& state = _plugins[0]->get_state ();
133 p->set_state (state, Stateful::loading_state_version);
140 PluginConfigChanged (); /* EMIT SIGNAL */
142 } else if (num < _plugins.size()) {
143 uint32_t diff = _plugins.size() - num;
144 for (uint32_t n= 0; n < diff; ++n) {
147 PluginConfigChanged (); /* EMIT SIGNAL */
155 PluginInsert::set_sinks (const ChanCount& c)
158 /* no signal, change will only be visible after re-config */
162 PluginInsert::set_outputs (const ChanCount& c)
164 bool changed = (_custom_out != c) && _custom_cfg;
167 PluginConfigChanged (); /* EMIT SIGNAL */
172 PluginInsert::set_custom_cfg (bool b)
174 bool changed = _custom_cfg != b;
177 PluginConfigChanged (); /* EMIT SIGNAL */
182 PluginInsert::set_preset_out (const ChanCount& c)
184 bool changed = _preset_out != c;
186 if (changed && !_custom_cfg) {
187 PluginConfigChanged (); /* EMIT SIGNAL */
193 PluginInsert::add_sidechain (uint32_t n_audio)
195 // caller must hold process lock
199 std::ostringstream n;
201 n << "Sidechain " << Session::next_name_id ();
203 n << "TO BE RESET FROM XML";
205 SideChain *sc = new SideChain (_session, n.str ());
206 _sidechain = boost::shared_ptr<SideChain> (sc);
207 _sidechain->activate ();
208 for (uint32_t n = 0; n < n_audio; ++n) {
209 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
211 PluginConfigChanged (); /* EMIT SIGNAL */
216 PluginInsert::del_sidechain ()
222 _sc_playback_latency = 0;
223 _sc_capture_latency = 0;
224 PluginConfigChanged (); /* EMIT SIGNAL */
229 PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback)
232 (_sc_playback_latency != playback || _sc_capture_latency != capture)) {
233 _sc_capture_latency = capture;
234 _sc_playback_latency = playback;
235 LatencyRange pl; pl.min = pl.max = playback;
236 LatencyRange cl; cl.min = cl.max = capture;
237 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback));
238 PortSet& ps (_sidechain->input ()->ports ());
239 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
240 p->set_private_latency_range (pl, true);
241 p->set_private_latency_range (cl, false);
247 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
249 if (which.type() != PluginAutomation)
252 boost::shared_ptr<AutomationControl> c
253 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
256 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
261 PluginInsert::output_streams() const
263 assert (_configured);
264 return _configured_out;
268 PluginInsert::input_streams() const
270 assert (_configured);
271 return _configured_in;
275 PluginInsert::internal_streams() const
277 assert (_configured);
278 return _configured_internal;
282 PluginInsert::internal_output_streams() const
284 assert (!_plugins.empty());
286 PluginInfoPtr info = _plugins.front()->get_info();
288 if (info->reconfigurable_io()) {
289 ChanCount out = _plugins.front()->output_streams ();
290 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
293 ChanCount out = info->n_outputs;
294 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
295 out.set_audio (out.n_audio() * _plugins.size());
296 out.set_midi (out.n_midi() * _plugins.size());
302 PluginInsert::internal_input_streams() const
304 assert (!_plugins.empty());
308 PluginInfoPtr info = _plugins.front()->get_info();
310 if (info->reconfigurable_io()) {
311 in = _plugins.front()->input_streams();
316 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
318 if (_match.method == Split) {
320 /* we are splitting 1 processor input to multiple plugin inputs,
321 so we have a maximum of 1 stream of each type.
323 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
324 if (in.get (*t) > 1) {
330 } else if (_match.method == Hide) {
332 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
333 in.set (*t, in.get (*t) - _match.hide.get (*t));
339 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
340 in.set (*t, in.get (*t) * _plugins.size ());
348 PluginInsert::natural_output_streams() const
351 if (is_channelstrip ()) {
352 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
355 return _plugins[0]->get_info()->n_outputs;
359 PluginInsert::natural_input_streams() const
362 if (is_channelstrip ()) {
363 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
366 return _plugins[0]->get_info()->n_inputs;
370 PluginInsert::sidechain_input_pins() const
372 return _cached_sidechain_pins;
376 PluginInsert::has_no_inputs() const
378 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
382 PluginInsert::has_no_audio_inputs() const
384 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
388 PluginInsert::plugin_latency () const {
389 return _plugins.front()->signal_latency ();
393 PluginInsert::needs_midi_input() const
395 PluginInfoPtr pip = _plugins[0]->get_info();
396 if (pip->needs_midi_input ()) {
399 return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
403 PluginInsert::has_output_presets (ChanCount in, ChanCount out)
405 if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) {
406 // collect possible configurations, prefer given in/out
407 _plugins[0]->can_support_io_configuration (in, out);
410 PluginOutputConfiguration ppc (_plugins[0]->possible_output ());
412 if (ppc.size () == 0) {
415 if (!strict_io () && ppc.size () == 1) {
419 if (strict_io () && ppc.size () == 1) {
420 // "stereo" is currently preferred default for instruments
421 if (ppc.find (2) != ppc.end ()) {
425 if (!needs_midi_input ()) {
432 PluginInsert::create_automatable_parameters ()
434 assert (!_plugins.empty());
436 boost::shared_ptr<Plugin> plugin = _plugins.front();
437 set<Evoral::Parameter> a = _plugins.front()->automatable ();
439 for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
440 if (!plugin->parameter_is_control (i) || !plugin->parameter_is_input (i)) {
443 Evoral::Parameter param (PluginAutomation, 0, i);
445 ParameterDescriptor desc;
446 plugin->get_parameter_descriptor(i, desc);
448 const bool automatable = a.find(param) != a.end();
451 can_automate (param);
453 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
454 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
456 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
459 plugin->set_automation_control (i, c);
463 const Plugin::PropertyDescriptors& pdl (plugin->get_supported_properties ());
464 for (Plugin::PropertyDescriptors::const_iterator p = pdl.begin(); p != pdl.end(); ++p) {
465 Evoral::Parameter param (PluginPropertyAutomation, 0, p->first);
466 const ParameterDescriptor& desc = plugin->get_property_descriptor(param.id());
467 if (desc.datatype != Variant::NOTHING) {
468 boost::shared_ptr<AutomationList> list;
469 if (Variant::type_is_numeric(desc.datatype)) {
470 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
472 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
476 _bypass_port = plugin->designated_bypass_port ();
478 if (_bypass_port != UINT32_MAX) {
479 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
480 if (0 == (ac->flags () & Controllable::NotAutomatable)) {
481 ac->alist()->automation_state_changed.connect_same_thread (*this, boost::bind (&PluginInsert::bypassable_changed, this));
482 ac->Changed.connect_same_thread (*this, boost::bind (&PluginInsert::enable_changed, this));
486 /** Called when something outside of this host has modified a plugin
487 * parameter. Responsible for propagating the change to two places:
489 * 1) anything listening to the Control itself
490 * 2) any replicated plugins that make up this PluginInsert.
492 * The PluginInsert is connected to the ParameterChangedExternally signal for
493 * the first (primary) plugin, and here broadcasts that change to any others.
495 * XXX We should probably drop this whole replication idea (Paul, October 2015)
496 * since it isn't used by sensible plugin APIs (AU, LV2).
499 PluginInsert::parameter_changed_externally (uint32_t which, float val)
501 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
503 /* First propagation: alter the underlying value of the control,
504 * without telling the plugin(s) that own/use it to set it.
511 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
514 pc->catch_up_with_external_value (val);
517 /* Second propagation: tell all plugins except the first to
518 update the value of this parameter. For sane plugin APIs,
519 there are no other plugins, so this is a no-op in those
523 Plugins::iterator i = _plugins.begin();
525 /* don't set the first plugin, just all the slaves */
527 if (i != _plugins.end()) {
529 for (; i != _plugins.end(); ++i) {
530 (*i)->set_parameter (which, val);
536 PluginInsert::set_block_size (pframes_t nframes)
539 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
540 if ((*i)->set_block_size (nframes) != 0) {
548 PluginInsert::activate ()
550 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
554 Processor::activate ();
555 if (_plugin_signal_latency != signal_latency ()) {
556 _plugin_signal_latency = signal_latency ();
562 PluginInsert::deactivate ()
564 Processor::deactivate ();
566 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
569 if (_plugin_signal_latency != signal_latency ()) {
570 _plugin_signal_latency = signal_latency ();
576 PluginInsert::flush ()
578 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
584 PluginInsert::enable (bool yn)
586 if (_bypass_port == UINT32_MAX) {
593 if (!_pending_active) {
596 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
597 ac->set_value (yn ? 1.0 : 0.0, Controllable::NoGroup);
603 PluginInsert::enabled () const
605 if (_bypass_port == UINT32_MAX) {
606 return Processor::enabled ();
608 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
609 return (ac->get_value () > 0 && _pending_active);
614 PluginInsert::bypassable () const
616 if (_bypass_port == UINT32_MAX) {
619 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
621 return !ac->automation_playback ();
626 PluginInsert::enable_changed ()
632 PluginInsert::bypassable_changed ()
634 BypassableChanged ();
638 PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const
640 // TODO optimize: store "unconnected" in a fixed set.
641 // it only changes on reconfiguration.
642 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
643 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
645 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
646 mapped = true; // in-place Midi bypass
648 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
649 PinMappings::const_iterator i = out_map.find (pc);
650 if (i == out_map.end ()) {
653 const ChanMapping& outmap (i->second);
654 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
656 uint32_t idx = outmap.get (*t, o, &valid);
657 if (valid && idx == out) {
664 bufs.get (*t, out).silence (nframes, offset);
671 PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes, framecnt_t offset, bool with_auto)
673 // TODO: atomically copy maps & _no_inplace
674 PinMappings in_map (_in_map);
675 PinMappings out_map (_out_map);
676 ChanMapping thru_map (_thru_map);
677 if (_mapping_changed) { // ToDo use a counters, increment until match.
678 _no_inplace = check_inplace ();
679 _mapping_changed = false;
682 if (_latency_changed) {
683 /* delaylines are configured with the max possible latency (as reported by the plugin)
684 * so this won't allocate memory (unless the plugin lied about its max latency)
685 * It may still 'click' though, since the fixed delaylines are not de-clicked.
686 * Then again plugin-latency changes are not click-free to begin with.
688 * This is also worst case, there is currently no concept of per-stream latency.
690 * e.g. Two identical latent plugins:
691 * 1st plugin: process left (latent), bypass right.
692 * 2nd plugin: bypass left, process right (latent).
693 * -> currently this yields 2 times latency of the plugin,
695 _latency_changed = false;
696 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
699 if (_match.method == Split && !_no_inplace) {
700 // TODO: also use this optimization if one source-buffer
701 // feeds _all_ *connected* inputs.
702 // currently this is *first* buffer to all only --
703 // see PluginInsert::check_inplace
704 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
705 if (_configured_internal.get (*t) == 0) {
709 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
710 assert (valid && first_idx == 0); // check_inplace ensures this
711 /* copy the first stream's buffer contents to the others */
712 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
713 uint32_t idx = in_map[0].get (*t, i, &valid);
716 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
720 /* the copy operation produces a linear monotonic input map */
721 in_map[0] = ChanMapping (natural_input_streams ());
724 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
725 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
731 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
733 boost::shared_ptr<AutomationControl> c
734 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
736 if (c->list() && c->automation_playback()) {
739 const float val = c->list()->rt_safe_eval (start, valid);
742 /* This is the ONLY place where we are
744 * AutomationControl::set_value_unchecked(). We
745 * know that the control is in
746 * automation playback mode, so no
747 * check on writable() is required
748 * (which must be done in AutomationControl::set_value()
751 c->set_value_unchecked(val);
758 /* Calculate if, and how many frames we need to collect for analysis */
759 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
760 _signal_analysis_collected_nframes);
761 if (nframes < collect_signal_nframes) { // we might not get all frames now
762 collect_signal_nframes = nframes;
765 if (collect_signal_nframes > 0) {
767 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
768 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
769 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
771 _signal_analysis_inputs.set_count(input_streams());
773 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
774 _signal_analysis_inputs.get_audio(i).read_from (
776 collect_signal_nframes,
777 _signal_analysis_collected_nframes); // offset is for target buffer
782 if (is_channelstrip ()) {
783 if (_configured_in.n_audio() > 0) {
784 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
785 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
787 _plugins.front()->connect_and_run (bufs, start, end, speed, mb_in_map, mb_out_map, nframes, offset);
789 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
790 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
796 // TODO optimize -- build maps once.
798 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
799 ARDOUR::ChanMapping used_outputs;
801 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
803 /* build used-output map */
804 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
805 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
806 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
808 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
810 used_outputs.set (*t, out_idx, 1); // mark as used
815 /* copy thru data to outputs before processing in-place */
816 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
817 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
819 uint32_t in_idx = thru_map.get (*t, out, &valid);
820 uint32_t m = out + natural_input_streams ().get (*t);
822 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
823 used_outputs.set (*t, out, 1); // mark as used
825 used_outputs.get (*t, out, &valid);
827 /* the plugin is expected to write here, but may not :(
828 * (e.g. drumgizmo w/o kit loaded)
830 inplace_bufs.get (*t, m).silence (nframes);
837 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
839 ARDOUR::ChanMapping i_in_map (natural_input_streams());
840 ARDOUR::ChanMapping i_out_map (out_map[pc]);
841 ARDOUR::ChanCount mapped;
843 /* map inputs sequentially */
844 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
845 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
847 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
848 uint32_t m = mapped.get (*t);
850 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
852 inplace_bufs.get (*t, m).silence (nframes, offset);
854 mapped.set (*t, m + 1);
858 /* outputs are mapped to inplace_bufs after the inputs */
859 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
860 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
863 if ((*i)->connect_and_run (inplace_bufs, start, end, speed, i_in_map, i_out_map, nframes, offset)) {
868 /* all instances have completed, now copy data that was written
869 * and zero unconnected buffers */
870 ARDOUR::ChanMapping nonzero_out (used_outputs);
871 if (has_midi_bypass ()) {
872 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
874 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
875 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
877 used_outputs.get (*t, out, &valid);
879 nonzero_out.get (*t, out, &valid);
881 bufs.get (*t, out).silence (nframes, offset);
884 uint32_t m = out + natural_input_streams ().get (*t);
885 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
890 /* in-place processing */
892 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
893 if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) {
897 // now silence unconnected outputs
898 inplace_silence_unconnected (bufs, _out_map, nframes, offset);
901 if (collect_signal_nframes > 0) {
903 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
904 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
906 _signal_analysis_outputs.set_count(output_streams());
908 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
909 _signal_analysis_outputs.get_audio(i).read_from(
911 collect_signal_nframes,
912 _signal_analysis_collected_nframes); // offset is for target buffer
915 _signal_analysis_collected_nframes += collect_signal_nframes;
916 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
918 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
919 _signal_analysis_collect_nframes_max = 0;
920 _signal_analysis_collected_nframes = 0;
922 AnalysisDataGathered(&_signal_analysis_inputs,
923 &_signal_analysis_outputs);
927 if (_plugin_signal_latency != signal_latency ()) {
928 _plugin_signal_latency = signal_latency ();
934 PluginInsert::bypass (BufferSet& bufs, pframes_t nframes)
936 /* bypass the plugin(s) not the whole processor.
937 * -> use mappings just like connect_and_run
940 // TODO: atomically copy maps & _no_inplace
941 const ChanMapping in_map (no_sc_input_map ());
942 const ChanMapping out_map (output_map ());
943 if (_mapping_changed) {
944 _no_inplace = check_inplace ();
945 _mapping_changed = false;
948 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
949 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
952 ChanMapping thru_map (_thru_map);
954 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
956 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
957 for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) {
958 inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0);
961 ARDOUR::ChanMapping used_outputs;
963 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
964 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
966 uint32_t in_idx = thru_map.get (*t, out, &valid);
968 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
969 used_outputs.set (*t, out, 1); // mark as used
973 // plugin no-op: assume every plugin has an internal identity map
974 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
975 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
977 uint32_t src_idx = out_map.get_src (*t, out, &valid);
981 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
985 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
986 used_outputs.set (*t, out, 1); // mark as used
989 // now silence all unused outputs
990 if (has_midi_bypass ()) {
991 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
993 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
994 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
996 used_outputs.get (*t, out, &valid);
998 bufs.get (*t, out).silence (nframes, 0);
1003 if (_match.method == Split) {
1004 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1005 if (_configured_internal.get (*t) == 0) {
1008 // copy/feeds _all_ *connected* inputs, copy the first buffer
1010 uint32_t first_idx = in_map.get (*t, 0, &valid);
1011 assert (valid && first_idx == 0); // check_inplace ensures this
1012 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1013 uint32_t idx = in_map.get (*t, i, &valid);
1016 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0);
1022 // apply output map and/or monotonic but not identity i/o mappings
1023 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1024 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1026 uint32_t src_idx = out_map.get_src (*t, out, &valid);
1028 bufs.get (*t, out).silence (nframes, 0);
1031 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
1033 bufs.get (*t, out).silence (nframes, 0);
1036 if (in_idx != src_idx) {
1037 bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0);
1045 PluginInsert::silence (framecnt_t nframes, framepos_t start_frame)
1051 _delaybuffers.flush ();
1053 ChanMapping in_map (natural_input_streams ());
1054 ChanMapping out_map (natural_output_streams ());
1055 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
1057 if (is_channelstrip ()) {
1058 if (_configured_in.n_audio() > 0) {
1059 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
1063 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1064 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
1069 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, double speed, pframes_t nframes, bool)
1072 // collect sidechain input for complete cycle (!)
1073 // TODO we need delaylines here for latency compensation
1074 _sidechain->run (bufs, start_frame, end_frame, speed, nframes, true);
1077 if (_pending_active) {
1078 /* run as normal if we are active or moving from inactive to active */
1080 if (_session.transport_rolling() || _session.bounce_processing()) {
1081 automation_run (bufs, start_frame, end_frame, speed, nframes);
1083 connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, false);
1087 bypass (bufs, nframes);
1088 _delaybuffers.flush ();
1091 _active = _pending_active;
1093 /* we have no idea whether the plugin generated silence or not, so mark
1094 * all buffers appropriately.
1099 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes)
1101 Evoral::ControlEvent next_event (0, 0.0f);
1102 framecnt_t offset = 0;
1104 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1107 connect_and_run (bufs, start, end, speed, nframes, offset, false);
1111 if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1113 /* no events have a time within the relevant range */
1115 connect_and_run (bufs, start, end, speed, nframes, offset, true);
1121 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - start), (framecnt_t) nframes);
1123 connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed
1129 if (!find_next_event (start, end, next_event)) {
1134 /* cleanup anything that is left to do */
1137 connect_and_run (bufs, start, start + nframes, speed, nframes, offset, true);
1142 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1144 if (param.type() != PluginAutomation)
1147 if (_plugins.empty()) {
1148 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1150 abort(); /*NOTREACHED*/
1153 return _plugins[0]->default_value (param.id());
1158 PluginInsert::can_reset_all_parameters ()
1161 uint32_t params = 0;
1162 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1164 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1166 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1170 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1176 if (ac->automation_state() & Play) {
1181 return all && (params > 0);
1185 PluginInsert::reset_parameters_to_default ()
1189 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1191 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1193 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1197 const float dflt = _plugins[0]->default_value (cid);
1198 const float curr = _plugins[0]->get_parameter (cid);
1204 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1209 if (ac->automation_state() & Play) {
1214 ac->set_value (dflt, Controllable::NoGroup);
1219 boost::shared_ptr<Plugin>
1220 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1222 boost::shared_ptr<LadspaPlugin> lp;
1223 boost::shared_ptr<LuaProc> lua;
1225 boost::shared_ptr<LV2Plugin> lv2p;
1227 #ifdef WINDOWS_VST_SUPPORT
1228 boost::shared_ptr<WindowsVSTPlugin> vp;
1230 #ifdef LXVST_SUPPORT
1231 boost::shared_ptr<LXVSTPlugin> lxvp;
1233 #ifdef AUDIOUNIT_SUPPORT
1234 boost::shared_ptr<AUPlugin> ap;
1237 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1238 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1239 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1240 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1242 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1243 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1245 #ifdef WINDOWS_VST_SUPPORT
1246 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1247 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1249 #ifdef LXVST_SUPPORT
1250 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1251 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1253 #ifdef AUDIOUNIT_SUPPORT
1254 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1255 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1259 fatal << string_compose (_("programming error: %1"),
1260 X_("unknown plugin type in PluginInsert::plugin_factory"))
1262 abort(); /*NOTREACHED*/
1263 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1267 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1268 if (num < _in_map.size()) {
1269 bool changed = _in_map[num] != m;
1271 changed |= sanitize_maps ();
1273 PluginMapChanged (); /* EMIT SIGNAL */
1274 _mapping_changed = true;
1275 _session.set_dirty();
1281 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1282 if (num < _out_map.size()) {
1283 bool changed = _out_map[num] != m;
1285 changed |= sanitize_maps ();
1287 PluginMapChanged (); /* EMIT SIGNAL */
1288 _mapping_changed = true;
1289 _session.set_dirty();
1295 PluginInsert::set_thru_map (ChanMapping m) {
1296 bool changed = _thru_map != m;
1298 changed |= sanitize_maps ();
1300 PluginMapChanged (); /* EMIT SIGNAL */
1301 _mapping_changed = true;
1302 _session.set_dirty();
1307 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1308 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1310 if (_configured) { return false; }
1311 _configured_in = in;
1312 _configured_out = out;
1316 _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1321 PluginInsert::input_map () const
1325 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1326 ChanMapping m (i->second);
1327 const ChanMapping::Mappings& mp ((*i).second.mappings());
1328 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1329 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1330 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1339 PluginInsert::no_sc_input_map () const
1343 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1344 ChanMapping m (i->second);
1345 const ChanMapping::Mappings& mp ((*i).second.mappings());
1346 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1347 uint32_t ins = natural_input_streams().get(tm->first) - _cached_sidechain_pins.get(tm->first);
1348 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1349 if (i->first < ins) {
1350 rv.set (tm->first, i->first + pc * ins, i->second);
1359 PluginInsert::output_map () const
1363 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1364 ChanMapping m (i->second);
1365 const ChanMapping::Mappings& mp ((*i).second.mappings());
1366 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1367 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1368 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1372 if (has_midi_bypass ()) {
1373 rv.set (DataType::MIDI, 0, 0);
1380 PluginInsert::has_midi_bypass () const
1382 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1383 && natural_output_streams ().n_midi () == 0) {
1390 PluginInsert::has_midi_thru () const
1392 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1393 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1401 PluginInsert::is_channelstrip () const {
1402 return _plugins.front()->is_channelstrip();
1407 PluginInsert::check_inplace ()
1409 bool inplace_ok = !_plugins.front()->inplace_broken ();
1411 if (_thru_map.n_total () > 0) {
1412 // TODO once midi-bypass is part of the mapping, ignore it
1416 if (_match.method == Split && inplace_ok) {
1417 assert (get_count() == 1);
1418 assert (_in_map.size () == 1);
1419 if (!_out_map[0].is_monotonic ()) {
1422 if (_configured_internal != _configured_in) {
1423 /* no sidechain -- TODO we could allow this with
1424 * some more logic in PluginInsert::connect_and_run().
1426 * PluginInsert::reset_map() already maps it.
1431 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1432 if (_configured_internal.get (*t) == 0) {
1436 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1437 if (!valid || first_idx != 0) {
1438 // so far only allow to copy the *first* stream's buffer to others
1441 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1442 uint32_t idx = _in_map[0].get (*t, i, &valid);
1443 if (valid && idx != first_idx) {
1452 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1457 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1458 if (!_in_map[pc].is_monotonic ()) {
1461 if (!_out_map[pc].is_monotonic ()) {
1467 /* check if every output is fed by the corresponding input
1469 * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2
1470 * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1)
1472 * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
1474 ChanMapping in_map (input_map ());
1475 const ChanMapping::Mappings out_m (output_map ().mappings ());
1476 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1477 for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1478 /* src-pin: c->first, out-port: c->second */
1480 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1481 if (valid && in_port != c->second) {
1489 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1490 return !inplace_ok; // no-inplace
1494 PluginInsert::sanitize_maps ()
1496 bool changed = false;
1497 /* strip dead wood */
1498 PinMappings new_ins;
1499 PinMappings new_outs;
1500 ChanMapping new_thru;
1502 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1504 ChanMapping new_out;
1505 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1506 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1508 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1509 if (valid && idx < _configured_internal.get (*t)) {
1510 new_in.set (*t, i, idx);
1513 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1515 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1516 if (valid && idx < _configured_out.get (*t)) {
1517 new_out.set (*t, o, idx);
1521 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1524 new_ins[pc] = new_in;
1525 new_outs[pc] = new_out;
1528 /* prevent dup output assignments */
1529 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1530 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1531 bool mapped = false;
1532 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1534 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1535 if (valid && mapped) {
1536 new_outs[pc].unset (*t, idx);
1544 /* remove excess thru */
1545 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1546 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1548 uint32_t idx = _thru_map.get (*t, o, &valid);
1549 if (valid && idx < _configured_internal.get (*t)) {
1550 new_thru.set (*t, o, idx);
1555 /* prevent out + thru, existing plugin outputs override thru */
1556 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1557 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1558 bool mapped = false;
1560 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1561 new_outs[pc].get_src (*t, o, &mapped);
1562 if (mapped) { break; }
1564 if (!mapped) { continue; }
1565 uint32_t idx = new_thru.get (*t, o, &valid);
1567 new_thru.unset (*t, idx);
1572 if (has_midi_bypass ()) {
1573 // TODO: include midi-bypass in the thru set,
1574 // remove dedicated handling.
1575 new_thru.unset (DataType::MIDI, 0);
1578 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1582 _out_map = new_outs;
1583 _thru_map = new_thru;
1589 PluginInsert::reset_map (bool emit)
1591 const PinMappings old_in (_in_map);
1592 const PinMappings old_out (_out_map);
1596 _thru_map = ChanMapping ();
1598 /* build input map */
1599 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1600 uint32_t sc = 0; // side-chain round-robin (all instances)
1602 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1603 const uint32_t nis = natural_input_streams ().get(*t);
1604 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1606 /* SC inputs are last in the plugin-insert.. */
1607 const uint32_t sc_start = _configured_in.get (*t);
1608 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1609 /* ...but may not be at the end of the plugin ports.
1610 * in case the side-chain is not the last port, shift connections back.
1611 * and connect to side-chain
1614 uint32_t ic = 0; // split inputs
1615 const uint32_t cend = _configured_in.get (*t);
1617 for (uint32_t in = 0; in < nis; ++in) {
1618 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1619 if (iod.is_sidechain) {
1620 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1621 if (sc_len > 0) {// side-chain may be hidden
1622 _in_map[pc].set (*t, in, sc_start + sc);
1623 sc = (sc + 1) % sc_len;
1627 if (_match.method == Split) {
1628 if (cend == 0) { continue; }
1629 if (_strict_io && ic + stride * pc >= cend) {
1632 /* connect *no* sidechain sinks in round-robin fashion */
1633 _in_map[pc].set (*t, in, ic + stride * pc);
1634 if (_strict_io && (ic + 1) == cend) {
1637 ic = (ic + 1) % cend;
1639 uint32_t s = in - shift;
1640 if (stride * pc + s < cend) {
1641 _in_map[pc].set (*t, in, s + stride * pc);
1649 /* build output map */
1651 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1652 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1653 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1654 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1659 if (old_in == _in_map && old_out == _out_map) {
1663 PluginMapChanged (); /* EMIT SIGNAL */
1664 _mapping_changed = true;
1665 _session.set_dirty();
1671 PluginInsert::configure_io (ChanCount in, ChanCount out)
1673 Match old_match = _match;
1675 ChanCount old_internal;
1679 old_pins = natural_input_streams();
1680 old_in = _configured_in;
1681 old_out = _configured_out;
1682 old_internal = _configured_internal;
1684 _configured_in = in;
1685 _configured_internal = in;
1686 _configured_out = out;
1689 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1690 * (currently _sidechain->configure_io always succeeds
1691 * since Processor::configure_io() succeeds)
1693 if (!_sidechain->configure_io (in, out)) {
1694 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1697 _configured_internal += _sidechain->input()->n_ports();
1699 // include (static_cast<Route*>owner())->name() ??
1700 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1703 /* get plugin configuration */
1704 _match = private_can_support_io_configuration (in, out);
1706 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1708 DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
1709 DEBUG_STR_APPEND(a, _match);
1710 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1714 /* set the matching method and number of plugins that we will use to meet this configuration */
1715 if (set_count (_match.plugins) == false) {
1716 PluginIoReConfigure (); /* EMIT SIGNAL */
1717 _configured = false;
1721 /* configure plugins */
1722 switch (_match.method) {
1725 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1726 PluginIoReConfigure (); /* EMIT SIGNAL */
1727 _configured = false;
1733 ChanCount din (_configured_internal);
1734 ChanCount dout (din); // hint
1736 if (_custom_sinks.n_total () > 0) {
1737 din = _custom_sinks;
1740 } else if (_preset_out.n_audio () > 0) {
1741 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1742 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1743 dout.set (DataType::AUDIO, 2);
1745 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1747 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1748 bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1750 if (useins.n_audio() == 0) {
1753 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1755 if (_plugins.front()->configure_io (useins, dout) == false) {
1756 PluginIoReConfigure (); /* EMIT SIGNAL */
1757 _configured = false;
1761 _custom_sinks = din;
1766 if (_plugins.front()->configure_io (in, out) == false) {
1767 PluginIoReConfigure (); /* EMIT SIGNAL */
1768 _configured = false;
1774 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",
1776 _configured ? "Y" : "N",
1777 _maps_from_state ? "Y" : "N",
1778 old_in == in ? "==" : "!=",
1779 old_out == out ? "==" : "!=",
1780 old_pins == natural_input_streams () ? "==" : "!=",
1781 old_match.method == _match.method ? "==" : "!=",
1782 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1783 _in_map.size() == get_count () ? "==" : "!=",
1784 _out_map.size() == get_count () ? "==" : "!="
1787 bool mapping_changed = false;
1788 if (old_in == in && old_out == out
1790 && old_pins == natural_input_streams ()
1791 && old_match.method == _match.method
1792 && old_match.custom_cfg == _match.custom_cfg
1793 && _in_map.size() == _out_map.size()
1794 && _in_map.size() == get_count ()
1796 assert (_maps_from_state == false);
1797 /* If the configuration has not changed, keep the mapping */
1798 mapping_changed = sanitize_maps ();
1799 } else if (_match.custom_cfg && _configured) {
1800 assert (_maps_from_state == false);
1801 /* don't touch the map in manual mode */
1802 mapping_changed = sanitize_maps ();
1805 if (is_channelstrip ()) {
1806 /* fake channel map - for wire display */
1809 _thru_map = ChanMapping ();
1810 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1811 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1812 /* set "thru" map for in-place forward of audio */
1813 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1814 _thru_map.set (DataType::AUDIO, i, i);
1816 /* and midi (after implicit 1st channel bypass) */
1817 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1818 _thru_map.set (DataType::MIDI, i, i);
1822 if (_maps_from_state && old_in == in && old_out == out) {
1823 mapping_changed = true;
1826 /* generate a new mapping */
1827 mapping_changed = reset_map (false);
1829 _maps_from_state = false;
1832 if (mapping_changed) {
1833 PluginMapChanged (); /* EMIT SIGNAL */
1836 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1839 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1840 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1842 DEBUG_STR_APPEND(a, "----><----\n");
1844 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1845 DEBUG_STR_APPEND(a, " * Inputs:\n");
1846 DEBUG_STR_APPEND(a, _in_map[pc]);
1847 DEBUG_STR_APPEND(a, " * Outputs:\n");
1848 DEBUG_STR_APPEND(a, _out_map[pc]);
1850 DEBUG_STR_APPEND(a, " * Thru:\n");
1851 DEBUG_STR_APPEND(a, _thru_map);
1852 DEBUG_STR_APPEND(a, "-------->>--------\n");
1853 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1858 _no_inplace = check_inplace ();
1859 _mapping_changed = false;
1861 /* only the "noinplace_buffers" thread buffers need to be this large,
1862 * this can be optimized. other buffers are fine with
1863 * ChanCount::max (natural_input_streams (), natural_output_streams())
1864 * and route.cc's max (configured_in, configured_out)
1866 * no-inplace copies "thru" outputs (to emulate in-place) for
1867 * all outputs (to prevent overwrite) into a temporary space
1868 * which also holds input buffers (in case the plugin does process
1869 * in-place and overwrites those).
1871 * this buffers need to be at least as
1872 * natural_input_streams () + possible outputs.
1874 * sidechain inputs add a constraint on the input:
1875 * configured input + sidechain (=_configured_internal)
1877 * NB. this also satisfies
1878 * max (natural_input_streams(), natural_output_streams())
1879 * which is needed for silence runs
1881 _required_buffers = ChanCount::max (_configured_internal,
1882 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1884 if (old_in != in || old_out != out || old_internal != _configured_internal
1885 || old_pins != natural_input_streams ()
1886 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1888 PluginIoReConfigure (); /* EMIT SIGNAL */
1891 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1892 _latency_changed = true;
1894 // we don't know the analysis window size, so we must work with the
1895 // current buffer size here. each request for data fills in these
1896 // buffers and the analyser makes sure it gets enough data for the
1898 session().ensure_buffer_set (_signal_analysis_inputs, in);
1899 _signal_analysis_inputs.set_count (in);
1901 session().ensure_buffer_set (_signal_analysis_outputs, out);
1902 _signal_analysis_outputs.set_count (out);
1904 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1907 return Processor::configure_io (in, out);
1910 /** Decide whether this PluginInsert can support a given IO configuration.
1911 * To do this, we run through a set of possible solutions in rough order of
1914 * @param in Required input channel count.
1915 * @param out Filled in with the output channel count if we return true.
1916 * @return true if the given IO configuration can be supported.
1919 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1922 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1924 return private_can_support_io_configuration (in, out).method != Impossible;
1928 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1930 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1931 // preseed hint (for variable i/o)
1932 out.set (DataType::AUDIO, _preset_out.n_audio ());
1935 Match rv = internal_can_support_io_configuration (in, out);
1937 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1938 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
1939 out.set (DataType::AUDIO, _preset_out.n_audio ());
1944 /** A private version of can_support_io_configuration which returns the method
1945 * by which the configuration can be matched, rather than just whether or not
1949 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1951 if (_plugins.empty()) {
1956 if (is_channelstrip ()) {
1958 return Match (ExactMatch, 1);
1962 /* if a user specified a custom cfg, so be it. */
1964 PluginInfoPtr info = _plugins.front()->get_info();
1966 if (info->reconfigurable_io()) {
1967 return Match (Delegate, 1, _strict_io, true);
1969 return Match (ExactMatch, get_count(), _strict_io, true);
1973 /* try automatic configuration */
1974 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1976 PluginInfoPtr info = _plugins.front()->get_info();
1977 ChanCount inputs = info->n_inputs;
1978 ChanCount outputs = info->n_outputs;
1980 /* handle case strict-i/o */
1981 if (_strict_io && m.method != Impossible) {
1984 /* special case MIDI instruments */
1985 if (needs_midi_input ()) {
1986 // output = midi-bypass + at most master-out channels.
1987 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1988 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1989 out = ChanCount::min (out, max_out);
1990 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
1996 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1997 /* replicate processor to match output count (generators and such)
1998 * at least enough to feed every output port. */
1999 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
2000 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2001 uint32_t nout = outputs.get (*t);
2002 if (nout == 0 || inx.get(*t) == 0) { continue; }
2003 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
2006 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
2007 return Match (Replicate, f, _strict_io);
2018 if (m.method != Impossible) {
2022 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2024 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
2026 if (info->reconfigurable_io()) {
2029 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2030 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2031 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
2033 // houston, we have a problem.
2034 return Match (Impossible, 0);
2037 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2038 return Match (Delegate, 1, _strict_io);
2041 ChanCount midi_bypass;
2042 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2043 midi_bypass.set (DataType::MIDI, 1);
2046 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
2048 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2049 uint32_t nin = ns_inputs.get (*t);
2050 uint32_t nout = outputs.get (*t);
2051 if (nin == 0 || inx.get(*t) == 0) { continue; }
2052 // prefer floor() so the count won't overly increase IFF (nin < nout)
2053 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
2055 if (f > 0 && outputs * f >= _configured_out) {
2056 out = outputs * f + midi_bypass;
2057 return Match (Replicate, f, _strict_io);
2060 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
2062 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2063 uint32_t nin = ns_inputs.get (*t);
2064 if (nin == 0 || inx.get(*t) == 0) { continue; }
2065 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2068 out = outputs * f + midi_bypass;
2069 return Match (Replicate, f, _strict_io);
2072 // add at least as many plugins needed to connect all inputs
2074 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2075 uint32_t nin = inputs.get (*t);
2076 if (nin == 0 || inx.get(*t) == 0) { continue; }
2077 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2079 out = outputs * f + midi_bypass;
2080 return Match (Replicate, f, _strict_io);
2083 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
2085 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
2087 if (_plugins.empty()) {
2091 PluginInfoPtr info = _plugins.front()->get_info();
2092 ChanCount in; in += inx;
2093 ChanCount midi_bypass;
2095 if (info->reconfigurable_io()) {
2096 /* Plugin has flexible I/O, so delegate to it
2097 * pre-seed outputs, plugin tries closest match
2100 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2101 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2102 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
2104 return Match (Impossible, 0);
2107 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2108 return Match (Delegate, 1);
2111 ChanCount inputs = info->n_inputs;
2112 ChanCount outputs = info->n_outputs;
2113 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2115 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2116 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
2117 midi_bypass.set (DataType::MIDI, 1);
2119 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
2120 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
2121 in.set(DataType::MIDI, 0);
2124 // add internally provided sidechain ports
2125 ChanCount insc = in + sidechain_input_ports ();
2127 bool no_inputs = true;
2128 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2129 if (inputs.get (*t) != 0) {
2136 /* no inputs so we can take any input configuration since we throw it away */
2137 out = outputs + midi_bypass;
2138 return Match (NoInputs, 1);
2141 /* Plugin inputs match requested inputs + side-chain-ports exactly */
2142 if (inputs == insc) {
2143 out = outputs + midi_bypass;
2144 return Match (ExactMatch, 1);
2147 /* Plugin inputs matches without side-chain-pins */
2148 if (ns_inputs == in) {
2149 out = outputs + midi_bypass;
2150 return Match (ExactMatch, 1);
2153 /* We may be able to run more than one copy of the plugin within this insert
2154 to cope with the insert having more inputs than the plugin.
2155 We allow replication only for plugins with either zero or 1 inputs and outputs
2156 for every valid data type.
2160 bool can_replicate = true;
2161 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
2163 // ignore side-chains
2164 uint32_t nin = ns_inputs.get (*t);
2166 // No inputs of this type
2167 if (nin == 0 && in.get(*t) == 0) {
2171 if (nin != 1 || outputs.get (*t) != 1) {
2172 can_replicate = false;
2176 // Potential factor not set yet
2178 f = in.get(*t) / nin;
2181 // Factor for this type does not match another type, can not replicate
2182 if (f != (in.get(*t) / nin)) {
2183 can_replicate = false;
2188 if (can_replicate && f > 0) {
2189 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2190 out.set (*t, outputs.get(*t) * f);
2193 return Match (Replicate, f);
2196 /* If the processor has exactly one input of a given type, and
2197 the plugin has more, we can feed the single processor input
2198 to some or all of the plugin inputs. This is rather
2199 special-case-y, but the 1-to-many case is by far the
2200 simplest. How do I split thy 2 processor inputs to 3
2201 plugin inputs? Let me count the ways ...
2204 bool can_split = true;
2205 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2207 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2208 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2210 if (!can_split_type && !nothing_to_do_for_type) {
2216 out = outputs + midi_bypass;
2217 return Match (Split, 1);
2220 /* If the plugin has more inputs than we want, we can `hide' some of them
2221 by feeding them silence.
2224 bool could_hide = false;
2225 bool cannot_hide = false;
2226 ChanCount hide_channels;
2228 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2229 if (inputs.get(*t) > in.get(*t)) {
2230 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2231 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2233 } else if (inputs.get(*t) < in.get(*t)) {
2234 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2239 if (could_hide && !cannot_hide) {
2240 out = outputs + midi_bypass;
2241 return Match (Hide, 1, false, false, hide_channels);
2244 return Match (Impossible, 0);
2249 PluginInsert::get_state ()
2251 return state (true);
2255 PluginInsert::state (bool full)
2257 XMLNode& node = Processor::state (full);
2259 node.add_property("type", _plugins[0]->state_node_name());
2260 node.add_property("unique-id", _plugins[0]->unique_id());
2261 node.add_property("count", string_compose("%1", _plugins.size()));
2263 /* remember actual i/o configuration (for later placeholder
2264 * in case the plugin goes missing) */
2265 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2266 node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2267 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2268 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2270 /* save custom i/o config */
2271 node.add_property("custom", _custom_cfg ? "yes" : "no");
2272 for (uint32_t pc = 0; pc < get_count(); ++pc) {
2274 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2275 node.add_child_nocopy (* _in_map[pc].state (tmp));
2276 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2277 node.add_child_nocopy (* _out_map[pc].state (tmp));
2279 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2282 node.add_child_nocopy (_sidechain->state (full));
2285 _plugins[0]->set_insert_id(this->id());
2286 node.add_child_nocopy (_plugins[0]->get_state());
2288 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2289 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2291 node.add_child_nocopy (ac->get_state());
2299 PluginInsert::set_control_ids (const XMLNode& node, int version)
2301 const XMLNodeList& nlist = node.children();
2302 XMLNodeConstIterator iter;
2303 set<Evoral::Parameter>::const_iterator p;
2305 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2306 if ((*iter)->name() == Controllable::xml_node_name) {
2307 XMLProperty const * prop;
2309 uint32_t p = (uint32_t)-1;
2311 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
2312 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2314 p = lv2plugin->port_index(prop->value().c_str());
2318 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
2319 p = atoi (prop->value());
2322 if (p != (uint32_t)-1) {
2324 /* this may create the new controllable */
2326 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2328 #ifndef NO_PLUGIN_STATE
2332 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2334 ac->set_state (**iter, version);
2343 PluginInsert::set_state(const XMLNode& node, int version)
2345 XMLNodeList nlist = node.children();
2346 XMLNodeIterator niter;
2347 XMLPropertyList plist;
2348 XMLProperty const * prop;
2349 ARDOUR::PluginType type;
2351 if ((prop = node.property ("type")) == 0) {
2352 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2356 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2357 type = ARDOUR::LADSPA;
2358 } else if (prop->value() == X_("lv2")) {
2360 } else if (prop->value() == X_("windows-vst")) {
2361 type = ARDOUR::Windows_VST;
2362 } else if (prop->value() == X_("lxvst")) {
2363 type = ARDOUR::LXVST;
2364 } else if (prop->value() == X_("audiounit")) {
2365 type = ARDOUR::AudioUnit;
2366 } else if (prop->value() == X_("luaproc")) {
2369 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2375 prop = node.property ("unique-id");
2378 #ifdef WINDOWS_VST_SUPPORT
2379 /* older sessions contain VST plugins with only an "id" field.
2382 if (type == ARDOUR::Windows_VST) {
2383 prop = node.property ("id");
2387 #ifdef LXVST_SUPPORT
2388 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2390 if (type == ARDOUR::LXVST) {
2391 prop = node.property ("id");
2397 error << _("Plugin has no unique ID field") << endmsg;
2402 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2404 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2405 * allow to move sessions windows <> linux */
2406 #ifdef LXVST_SUPPORT
2407 if (plugin == 0 && type == ARDOUR::Windows_VST) {
2408 type = ARDOUR::LXVST;
2409 plugin = find_plugin (_session, prop->value(), type);
2413 #ifdef WINDOWS_VST_SUPPORT
2414 if (plugin == 0 && type == ARDOUR::LXVST) {
2415 type = ARDOUR::Windows_VST;
2416 plugin = find_plugin (_session, prop->value(), type);
2420 if (plugin == 0 && type == ARDOUR::Lua) {
2421 /* unique ID (sha1 of script) was not found,
2422 * load the plugin from the serialized version in the
2423 * session-file instead.
2425 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2426 XMLNode *ls = node.child (lp->state_node_name().c_str());
2428 lp->set_script_from_state (*ls);
2434 error << string_compose(
2435 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2436 "Perhaps it was removed or moved since it was last used."),
2442 // The name of the PluginInsert comes from the plugin, nothing else
2443 _name = plugin->get_info()->name;
2447 // Processor::set_state() will set this, but too late
2448 // for it to be available when setting up plugin
2449 // state. We can't call Processor::set_state() until
2450 // the plugins themselves are created and added.
2454 if (_plugins.empty()) {
2455 /* if we are adding the first plugin, we will need to set
2456 up automatable controls.
2458 add_plugin (plugin);
2459 create_automatable_parameters ();
2460 set_control_ids (node, version);
2463 if ((prop = node.property ("count")) != 0) {
2464 sscanf (prop->value().c_str(), "%u", &count);
2467 if (_plugins.size() != count) {
2468 for (uint32_t n = 1; n < count; ++n) {
2469 add_plugin (plugin_factory (plugin));
2473 Processor::set_state (node, version);
2475 PBD::ID new_id = this->id();
2476 PBD::ID old_id = this->id();
2478 if ((prop = node.property ("id")) != 0) {
2479 old_id = prop->value ();
2482 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2484 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2485 and set all plugins to the same state.
2488 if ((*niter)->name() == plugin->state_node_name()) {
2490 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2491 /* Plugin state can include external files which are named after the ID.
2493 * If regenerate_xml_or_string_ids() is set, the ID will already have
2494 * been changed, so we need to use the old ID from the XML to load the
2495 * state and then update the ID.
2497 * When copying a plugin-state, route_ui takes care of of updating the ID,
2498 * but we need to call set_insert_id() to clear the cached plugin-state
2499 * and force a change.
2501 if (!regenerate_xml_or_string_ids ()) {
2502 (*i)->set_insert_id (new_id);
2504 (*i)->set_insert_id (old_id);
2507 (*i)->set_state (**niter, version);
2509 if (regenerate_xml_or_string_ids ()) {
2510 (*i)->set_insert_id (new_id);
2518 if (version < 3000) {
2520 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2521 this is all handled by Automatable
2524 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2525 if ((*niter)->name() == "Redirect") {
2526 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2527 Processor::set_state (**niter, version);
2532 set_parameter_state_2X (node, version);
2535 if ((prop = node.property (X_("custom"))) != 0) {
2536 _custom_cfg = string_is_affirmative (prop->value());
2539 uint32_t in_maps = 0;
2540 uint32_t out_maps = 0;
2541 XMLNodeList kids = node.children ();
2542 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2543 if ((*i)->name() == X_("ConfiguredInput")) {
2544 _configured_in = ChanCount(**i);
2546 if ((*i)->name() == X_("CustomSinks")) {
2547 _custom_sinks = ChanCount(**i);
2549 if ((*i)->name() == X_("ConfiguredOutput")) {
2550 _custom_out = ChanCount(**i);
2551 _configured_out = ChanCount(**i);
2553 if ((*i)->name() == X_("PresetOutput")) {
2554 _preset_out = ChanCount(**i);
2556 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2557 long pc = atol (&((*i)->name().c_str()[9]));
2558 if (pc >= 0 && pc <= (long) get_count()) {
2559 _in_map[pc] = ChanMapping (**i);
2563 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2564 long pc = atol (&((*i)->name().c_str()[10]));
2565 if (pc >= 0 && pc <= (long) get_count()) {
2566 _out_map[pc] = ChanMapping (**i);
2570 if ((*i)->name () == "ThruMap") {
2571 _thru_map = ChanMapping (**i);
2574 // sidechain is a Processor (IO)
2575 if ((*i)->name () == Processor::state_node_name) {
2579 _sidechain->set_state (**i, version);
2583 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2584 _maps_from_state = true;
2587 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2591 (*i)->deactivate ();
2595 PluginConfigChanged (); /* EMIT SIGNAL */
2600 PluginInsert::update_id (PBD::ID id)
2603 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2604 (*i)->set_insert_id (id);
2609 PluginInsert::set_state_dir (const std::string& d)
2611 // state() only saves the state of the first plugin
2612 _plugins[0]->set_state_dir (d);
2616 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2618 XMLNodeList nlist = node.children();
2619 XMLNodeIterator niter;
2621 /* look for port automation node */
2623 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2625 if ((*niter)->name() != port_automation_node_name) {
2630 XMLProperty const * cprop;
2631 XMLNodeConstIterator iter;
2636 cnodes = (*niter)->children ("port");
2638 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2642 if ((cprop = child->property("number")) != 0) {
2643 port = cprop->value().c_str();
2645 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2649 sscanf (port, "%" PRIu32, &port_id);
2651 if (port_id >= _plugins[0]->parameter_count()) {
2652 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2656 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2657 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2659 if (c && c->alist()) {
2660 if (!child->children().empty()) {
2661 c->alist()->set_state (*child->children().front(), version);
2663 /* In some cases 2.X saves lists with min_yval and max_yval
2664 being FLT_MIN and FLT_MAX respectively. This causes problems
2665 in A3 because these min/max values are used to compute
2666 where GUI control points should be drawn. If we see such
2667 values, `correct' them to the min/max of the appropriate
2671 float min_y = c->alist()->get_min_y ();
2672 float max_y = c->alist()->get_max_y ();
2674 ParameterDescriptor desc;
2675 _plugins.front()->get_parameter_descriptor (port_id, desc);
2677 if (min_y == FLT_MIN) {
2681 if (max_y == FLT_MAX) {
2685 c->alist()->set_yrange (min_y, max_y);
2688 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2700 PluginInsert::describe_parameter (Evoral::Parameter param)
2702 if (param.type() == PluginAutomation) {
2703 return _plugins[0]->describe_parameter (param);
2704 } else if (param.type() == PluginPropertyAutomation) {
2705 boost::shared_ptr<AutomationControl> c(automation_control(param));
2706 if (c && !c->desc().label.empty()) {
2707 return c->desc().label;
2710 return Automatable::describe_parameter(param);
2714 PluginInsert::signal_latency() const
2716 if (!_pending_active) {
2719 if (_user_latency) {
2720 return _user_latency;
2723 return _plugins[0]->signal_latency ();
2727 PluginInsert::type ()
2729 return plugin()->get_info()->type;
2732 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2733 const Evoral::Parameter& param,
2734 const ParameterDescriptor& desc,
2735 boost::shared_ptr<AutomationList> list)
2736 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2740 alist()->reset_default (desc.normal);
2742 list->set_interpolation(Evoral::ControlList::Discrete);
2747 /** @param val `user' value */
2750 PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2752 /* FIXME: probably should be taking out some lock here.. */
2754 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2755 (*i)->set_parameter (_list->parameter().id(), user_val);
2758 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2760 iasp->set_parameter (_list->parameter().id(), user_val);
2763 AutomationControl::actually_set_value (user_val, group_override);
2767 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2769 AutomationControl::actually_set_value (user_val, Controllable::NoGroup);
2773 PluginInsert::PluginControl::get_state ()
2777 XMLNode& node (AutomationControl::get_state());
2778 ss << parameter().id();
2779 node.add_property (X_("parameter"), ss.str());
2781 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2783 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2790 /** @return `user' val */
2792 PluginInsert::PluginControl::get_value () const
2794 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2800 return plugin->get_parameter (_list->parameter().id());
2803 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2804 const Evoral::Parameter& param,
2805 const ParameterDescriptor& desc,
2806 boost::shared_ptr<AutomationList> list)
2807 : AutomationControl (p->session(), param, desc, list)
2811 alist()->set_yrange (desc.lower, desc.upper);
2812 alist()->reset_default (desc.normal);
2817 PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd)
2819 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2820 This is lossy, but better than nothing until Ardour's automation system
2821 can handle various datatypes all the way down. */
2822 const Variant value(_desc.datatype, user_val);
2823 if (value.type() == Variant::NOTHING) {
2824 error << "set_value(double) called for non-numeric property" << endmsg;
2828 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2829 (*i)->set_property(_list->parameter().id(), value);
2834 AutomationControl::actually_set_value (user_val, gcd);
2838 PluginInsert::PluginPropertyControl::get_state ()
2842 XMLNode& node (AutomationControl::get_state());
2843 ss << parameter().id();
2844 node.add_property (X_("property"), ss.str());
2845 node.remove_property (X_("value"));
2851 PluginInsert::PluginPropertyControl::get_value () const
2853 return _value.to_double();
2856 boost::shared_ptr<Plugin>
2857 PluginInsert::get_impulse_analysis_plugin()
2859 boost::shared_ptr<Plugin> ret;
2860 if (_impulseAnalysisPlugin.expired()) {
2861 // LV2 in particular uses various _session params
2862 // during init() -- most notably block_size..
2864 ret = plugin_factory(_plugins[0]);
2865 ret->configure_io (internal_input_streams (), internal_output_streams ());
2866 _impulseAnalysisPlugin = ret;
2868 ret = _impulseAnalysisPlugin.lock();
2875 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2877 // called from outside the audio thread, so this should be safe
2878 // only do audio as analysis is (currently) only for audio plugins
2879 _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes);
2880 _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
2882 _signal_analysis_collected_nframes = 0;
2883 _signal_analysis_collect_nframes_max = nframes;
2886 /** Add a plugin to our list */
2888 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2890 plugin->set_insert_id (this->id());
2892 if (_plugins.empty()) {
2893 /* first (and probably only) plugin instance - connect to relevant signals */
2895 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2896 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2897 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2898 _custom_sinks = plugin->get_info()->n_inputs;
2899 // cache sidechain port count
2900 _cached_sidechain_pins.reset ();
2901 const ChanCount& nis (plugin->get_info()->n_inputs);
2902 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2903 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2904 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2905 if (iod.is_sidechain) {
2906 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2911 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2912 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2914 vst->set_insert (this, _plugins.size ());
2918 _plugins.push_back (plugin);
2922 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
2925 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2926 if (! (*i)->load_preset (pr)) {
2934 PluginInsert::realtime_handle_transport_stopped ()
2936 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2937 (*i)->realtime_handle_transport_stopped ();
2942 PluginInsert::realtime_locate ()
2944 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2945 (*i)->realtime_locate ();
2950 PluginInsert::monitoring_changed ()
2952 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2953 (*i)->monitoring_changed ();
2958 PluginInsert::latency_changed ()
2960 // this is called in RT context, LatencyChanged is emitted after run()
2961 _latency_changed = true;
2962 // XXX This also needs a proper API not an owner() hack.
2963 static_cast<Route*>(owner ())->processor_latency_changed (); /* EMIT SIGNAL */
2967 PluginInsert::start_touch (uint32_t param_id)
2969 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2971 ac->start_touch (session().audible_frame());
2976 PluginInsert::end_touch (uint32_t param_id)
2978 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2980 ac->stop_touch (true, session().audible_frame());
2984 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2987 case PluginInsert::Impossible: o << "Impossible"; break;
2988 case PluginInsert::Delegate: o << "Delegate"; break;
2989 case PluginInsert::NoInputs: o << "NoInputs"; break;
2990 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2991 case PluginInsert::Replicate: o << "Replicate"; break;
2992 case PluginInsert::Split: o << "Split"; break;
2993 case PluginInsert::Hide: o << "Hide"; break;
2995 o << " cnt: " << m.plugins
2996 << (m.strict_io ? " strict-io" : "")
2997 << (m.custom_cfg ? " custom-cfg" : "");
2998 if (m.method == PluginInsert::Hide) {
2999 o << " hide: " << m.hide;