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)
79 , _bypass_port (UINT32_MAX)
81 /* the first is the master */
85 create_automatable_parameters ();
86 const ChanCount& sc (sidechain_input_pins ());
87 if (sc.n_audio () > 0) {
88 add_sidechain (sc.n_audio ());
93 PluginInsert::~PluginInsert ()
98 PluginInsert::set_strict_io (bool b)
100 bool changed = _strict_io != b;
103 PluginConfigChanged (); /* EMIT SIGNAL */
108 PluginInsert::set_count (uint32_t num)
110 bool require_state = !_plugins.empty();
112 if (require_state && num > 1 && plugin (0)->get_info ()->type == ARDOUR::AudioUnit) {
113 // we don't allow to replicate AUs
117 /* this is a bad idea.... we shouldn't do this while active.
118 * only a route holding their redirect_lock should be calling this
123 } else if (num > _plugins.size()) {
124 uint32_t diff = num - _plugins.size();
126 for (uint32_t n = 0; n < diff; ++n) {
127 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
131 XMLNode& state = _plugins[0]->get_state ();
132 p->set_state (state, Stateful::loading_state_version);
139 PluginConfigChanged (); /* EMIT SIGNAL */
141 } else if (num < _plugins.size()) {
142 uint32_t diff = _plugins.size() - num;
143 for (uint32_t n= 0; n < diff; ++n) {
146 PluginConfigChanged (); /* EMIT SIGNAL */
154 PluginInsert::set_sinks (const ChanCount& c)
157 /* no signal, change will only be visible after re-config */
161 PluginInsert::set_outputs (const ChanCount& c)
163 bool changed = (_custom_out != c) && _custom_cfg;
166 PluginConfigChanged (); /* EMIT SIGNAL */
171 PluginInsert::set_custom_cfg (bool b)
173 bool changed = _custom_cfg != b;
176 PluginConfigChanged (); /* EMIT SIGNAL */
181 PluginInsert::set_preset_out (const ChanCount& c)
183 bool changed = _preset_out != c;
185 if (changed && !_custom_cfg) {
186 PluginConfigChanged (); /* EMIT SIGNAL */
192 PluginInsert::add_sidechain (uint32_t n_audio)
194 // caller must hold process lock
198 std::ostringstream n;
200 n << "Sidechain " << Session::next_name_id ();
202 n << "TO BE RESET FROM XML";
204 SideChain *sc = new SideChain (_session, n.str ());
205 _sidechain = boost::shared_ptr<SideChain> (sc);
206 _sidechain->activate ();
207 for (uint32_t n = 0; n < n_audio; ++n) {
208 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
210 PluginConfigChanged (); /* EMIT SIGNAL */
215 PluginInsert::del_sidechain ()
221 _sc_playback_latency = 0;
222 _sc_capture_latency = 0;
223 PluginConfigChanged (); /* EMIT SIGNAL */
228 PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback)
231 (_sc_playback_latency != playback || _sc_capture_latency != capture)) {
232 _sc_capture_latency = capture;
233 _sc_playback_latency = playback;
234 LatencyRange pl; pl.min = pl.max = playback;
235 LatencyRange cl; cl.min = cl.max = capture;
236 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback));
237 PortSet& ps (_sidechain->input ()->ports ());
238 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
239 p->set_private_latency_range (pl, true);
240 p->set_private_latency_range (cl, false);
246 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
248 if (which.type() != PluginAutomation)
251 boost::shared_ptr<AutomationControl> c
252 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
255 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
260 PluginInsert::output_streams() const
262 assert (_configured);
263 return _configured_out;
267 PluginInsert::input_streams() const
269 assert (_configured);
270 return _configured_in;
274 PluginInsert::internal_streams() const
276 assert (_configured);
277 return _configured_internal;
281 PluginInsert::internal_output_streams() const
283 assert (!_plugins.empty());
285 PluginInfoPtr info = _plugins.front()->get_info();
287 if (info->reconfigurable_io()) {
288 ChanCount out = _plugins.front()->output_streams ();
289 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
292 ChanCount out = info->n_outputs;
293 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
294 out.set_audio (out.n_audio() * _plugins.size());
295 out.set_midi (out.n_midi() * _plugins.size());
301 PluginInsert::internal_input_streams() const
303 assert (!_plugins.empty());
307 PluginInfoPtr info = _plugins.front()->get_info();
309 if (info->reconfigurable_io()) {
310 in = _plugins.front()->input_streams();
315 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
317 if (_match.method == Split) {
319 /* we are splitting 1 processor input to multiple plugin inputs,
320 so we have a maximum of 1 stream of each type.
322 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
323 if (in.get (*t) > 1) {
329 } else if (_match.method == Hide) {
331 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
332 in.set (*t, in.get (*t) - _match.hide.get (*t));
338 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
339 in.set (*t, in.get (*t) * _plugins.size ());
347 PluginInsert::natural_output_streams() const
350 if (is_channelstrip ()) {
351 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
354 return _plugins[0]->get_info()->n_outputs;
358 PluginInsert::natural_input_streams() const
361 if (is_channelstrip ()) {
362 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
365 return _plugins[0]->get_info()->n_inputs;
369 PluginInsert::sidechain_input_pins() const
371 return _cached_sidechain_pins;
375 PluginInsert::has_no_inputs() const
377 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
381 PluginInsert::has_no_audio_inputs() const
383 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
387 PluginInsert::plugin_latency () const {
388 return _plugins.front()->signal_latency ();
392 PluginInsert::needs_midi_input() const
394 PluginInfoPtr pip = _plugins[0]->get_info();
395 if (pip->needs_midi_input ()) {
398 return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
402 PluginInsert::has_output_presets (ChanCount in, ChanCount out)
404 if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) {
405 // collect possible configurations, prefer given in/out
406 _plugins[0]->can_support_io_configuration (in, out);
409 PluginOutputConfiguration ppc (_plugins[0]->possible_output ());
411 if (ppc.size () == 0) {
414 if (!strict_io () && ppc.size () == 1) {
418 if (strict_io () && ppc.size () == 1) {
419 // "stereo" is currently preferred default for instruments
420 if (ppc.find (2) != ppc.end ()) {
424 if (!needs_midi_input ()) {
431 PluginInsert::create_automatable_parameters ()
433 assert (!_plugins.empty());
435 boost::shared_ptr<Plugin> plugin = _plugins.front();
436 set<Evoral::Parameter> a = _plugins.front()->automatable ();
438 for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
439 if (!plugin->parameter_is_control (i) || !plugin->parameter_is_input (i)) {
442 Evoral::Parameter param (PluginAutomation, 0, i);
444 ParameterDescriptor desc;
445 plugin->get_parameter_descriptor(i, desc);
447 const bool automatable = a.find(param) != a.end();
450 can_automate (param);
452 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
453 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
455 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
458 plugin->set_automation_control (i, c);
462 const Plugin::PropertyDescriptors& pdl (plugin->get_supported_properties ());
463 for (Plugin::PropertyDescriptors::const_iterator p = pdl.begin(); p != pdl.end(); ++p) {
464 Evoral::Parameter param (PluginPropertyAutomation, 0, p->first);
465 const ParameterDescriptor& desc = plugin->get_property_descriptor(param.id());
466 if (desc.datatype != Variant::NOTHING) {
467 boost::shared_ptr<AutomationList> list;
468 if (Variant::type_is_numeric(desc.datatype)) {
469 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
471 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
475 _bypass_port = plugin->designated_bypass_port ();
477 if (_bypass_port != UINT32_MAX) {
478 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
479 if (0 == (ac->flags () & Controllable::NotAutomatable)) {
480 ac->alist()->automation_state_changed.connect_same_thread (*this, boost::bind (&PluginInsert::bypassable_changed, this));
481 ac->Changed.connect_same_thread (*this, boost::bind (&PluginInsert::enable_changed, this));
485 /** Called when something outside of this host has modified a plugin
486 * parameter. Responsible for propagating the change to two places:
488 * 1) anything listening to the Control itself
489 * 2) any replicated plugins that make up this PluginInsert.
491 * The PluginInsert is connected to the ParameterChangedExternally signal for
492 * the first (primary) plugin, and here broadcasts that change to any others.
494 * XXX We should probably drop this whole replication idea (Paul, October 2015)
495 * since it isn't used by sensible plugin APIs (AU, LV2).
498 PluginInsert::parameter_changed_externally (uint32_t which, float val)
500 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
502 /* First propagation: alter the underlying value of the control,
503 * without telling the plugin(s) that own/use it to set it.
510 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
513 pc->catch_up_with_external_value (val);
516 /* Second propagation: tell all plugins except the first to
517 update the value of this parameter. For sane plugin APIs,
518 there are no other plugins, so this is a no-op in those
522 Plugins::iterator i = _plugins.begin();
524 /* don't set the first plugin, just all the slaves */
526 if (i != _plugins.end()) {
528 for (; i != _plugins.end(); ++i) {
529 (*i)->set_parameter (which, val);
535 PluginInsert::set_block_size (pframes_t nframes)
538 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
539 if ((*i)->set_block_size (nframes) != 0) {
547 PluginInsert::activate ()
549 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
553 Processor::activate ();
557 PluginInsert::deactivate ()
559 Processor::deactivate ();
561 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
567 PluginInsert::flush ()
569 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
575 PluginInsert::enable (bool yn)
577 if (_bypass_port == UINT32_MAX) {
584 if (!_pending_active) {
587 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
588 ac->set_value (yn ? 1.0 : 0.0, Controllable::NoGroup);
594 PluginInsert::enabled () const
596 if (_bypass_port == UINT32_MAX) {
597 return Processor::enabled ();
599 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
600 return (ac->get_value () > 0 && _pending_active);
605 PluginInsert::bypassable () const
607 if (_bypass_port == UINT32_MAX) {
610 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
612 return !ac->automation_playback ();
617 PluginInsert::enable_changed ()
623 PluginInsert::bypassable_changed ()
625 BypassableChanged ();
629 PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const
631 // TODO optimize: store "unconnected" in a fixed set.
632 // it only changes on reconfiguration.
633 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
634 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
636 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
637 mapped = true; // in-place Midi bypass
639 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
640 PinMappings::const_iterator i = out_map.find (pc);
641 if (i == out_map.end ()) {
644 const ChanMapping& outmap (i->second);
645 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
647 uint32_t idx = outmap.get (*t, o, &valid);
648 if (valid && idx == out) {
655 bufs.get (*t, out).silence (nframes, offset);
662 PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes, framecnt_t offset, bool with_auto)
664 // TODO: atomically copy maps & _no_inplace
665 PinMappings in_map (_in_map);
666 PinMappings out_map (_out_map);
667 ChanMapping thru_map (_thru_map);
668 if (_mapping_changed) { // ToDo use a counters, increment until match.
669 _no_inplace = check_inplace ();
670 _mapping_changed = false;
673 if (_latency_changed) {
674 /* delaylines are configured with the max possible latency (as reported by the plugin)
675 * so this won't allocate memory (unless the plugin lied about its max latency)
676 * It may still 'click' though, since the fixed delaylines are not de-clicked.
677 * Then again plugin-latency changes are not click-free to begin with.
679 * This is also worst case, there is currently no concept of per-stream latency.
681 * e.g. Two identical latent plugins:
682 * 1st plugin: process left (latent), bypass right.
683 * 2nd plugin: bypass left, process right (latent).
684 * -> currently this yields 2 times latency of the plugin,
686 _latency_changed = false;
687 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
690 if (_match.method == Split && !_no_inplace) {
691 // TODO: also use this optimization if one source-buffer
692 // feeds _all_ *connected* inputs.
693 // currently this is *first* buffer to all only --
694 // see PluginInsert::check_inplace
695 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
696 if (_configured_internal.get (*t) == 0) {
700 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
701 assert (valid && first_idx == 0); // check_inplace ensures this
702 /* copy the first stream's buffer contents to the others */
703 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
704 uint32_t idx = in_map[0].get (*t, i, &valid);
707 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
711 /* the copy operation produces a linear monotonic input map */
712 in_map[0] = ChanMapping (natural_input_streams ());
715 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
716 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
722 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
724 boost::shared_ptr<AutomationControl> c
725 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
727 if (c->list() && c->automation_playback()) {
730 const float val = c->list()->rt_safe_eval (start, valid);
733 /* This is the ONLY place where we are
735 * AutomationControl::set_value_unchecked(). We
736 * know that the control is in
737 * automation playback mode, so no
738 * check on writable() is required
739 * (which must be done in AutomationControl::set_value()
742 c->set_value_unchecked(val);
749 /* Calculate if, and how many frames we need to collect for analysis */
750 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
751 _signal_analysis_collected_nframes);
752 if (nframes < collect_signal_nframes) { // we might not get all frames now
753 collect_signal_nframes = nframes;
756 if (collect_signal_nframes > 0) {
758 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
759 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
760 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
762 _signal_analysis_inputs.set_count(input_streams());
764 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
765 _signal_analysis_inputs.get_audio(i).read_from (
767 collect_signal_nframes,
768 _signal_analysis_collected_nframes); // offset is for target buffer
773 if (is_channelstrip ()) {
774 if (_configured_in.n_audio() > 0) {
775 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
776 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
778 _plugins.front()->connect_and_run (bufs, start, end, speed, mb_in_map, mb_out_map, nframes, offset);
780 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
781 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
787 // TODO optimize -- build maps once.
789 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
790 ARDOUR::ChanMapping used_outputs;
792 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
794 /* build used-output map */
795 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
796 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
797 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
799 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
801 used_outputs.set (*t, out_idx, 1); // mark as used
806 /* copy thru data to outputs before processing in-place */
807 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
808 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
810 uint32_t in_idx = thru_map.get (*t, out, &valid);
811 uint32_t m = out + natural_input_streams ().get (*t);
813 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
814 used_outputs.set (*t, out, 1); // mark as used
816 used_outputs.get (*t, out, &valid);
818 /* the plugin is expected to write here, but may not :(
819 * (e.g. drumgizmo w/o kit loaded)
821 inplace_bufs.get (*t, m).silence (nframes);
828 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
830 ARDOUR::ChanMapping i_in_map (natural_input_streams());
831 ARDOUR::ChanMapping i_out_map (out_map[pc]);
832 ARDOUR::ChanCount mapped;
834 /* map inputs sequentially */
835 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
836 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
838 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
839 uint32_t m = mapped.get (*t);
841 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
843 inplace_bufs.get (*t, m).silence (nframes, offset);
845 mapped.set (*t, m + 1);
849 /* outputs are mapped to inplace_bufs after the inputs */
850 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
851 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
854 if ((*i)->connect_and_run (inplace_bufs, start, end, speed, i_in_map, i_out_map, nframes, offset)) {
859 /* all instances have completed, now copy data that was written
860 * and zero unconnected buffers */
861 ARDOUR::ChanMapping nonzero_out (used_outputs);
862 if (has_midi_bypass ()) {
863 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
865 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
866 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
868 used_outputs.get (*t, out, &valid);
870 nonzero_out.get (*t, out, &valid);
872 bufs.get (*t, out).silence (nframes, offset);
875 uint32_t m = out + natural_input_streams ().get (*t);
876 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
881 /* in-place processing */
883 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
884 if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) {
888 // now silence unconnected outputs
889 inplace_silence_unconnected (bufs, _out_map, nframes, offset);
892 if (collect_signal_nframes > 0) {
894 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
895 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
897 _signal_analysis_outputs.set_count(output_streams());
899 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
900 _signal_analysis_outputs.get_audio(i).read_from(
902 collect_signal_nframes,
903 _signal_analysis_collected_nframes); // offset is for target buffer
906 _signal_analysis_collected_nframes += collect_signal_nframes;
907 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
909 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
910 _signal_analysis_collect_nframes_max = 0;
911 _signal_analysis_collected_nframes = 0;
913 AnalysisDataGathered(&_signal_analysis_inputs,
914 &_signal_analysis_outputs);
920 PluginInsert::bypass (BufferSet& bufs, pframes_t nframes)
922 /* bypass the plugin(s) not the whole processor.
923 * -> use mappings just like connect_and_run
926 // TODO: atomically copy maps & _no_inplace
927 const ChanMapping in_map (no_sc_input_map ());
928 const ChanMapping out_map (output_map ());
929 if (_mapping_changed) {
930 _no_inplace = check_inplace ();
931 _mapping_changed = false;
934 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
935 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
938 ChanMapping thru_map (_thru_map);
940 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
942 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
943 for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) {
944 inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0);
947 ARDOUR::ChanMapping used_outputs;
949 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
950 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
952 uint32_t in_idx = thru_map.get (*t, out, &valid);
954 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
955 used_outputs.set (*t, out, 1); // mark as used
959 // plugin no-op: assume every plugin has an internal identity map
960 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
961 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
963 uint32_t src_idx = out_map.get_src (*t, out, &valid);
967 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
971 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
972 used_outputs.set (*t, out, 1); // mark as used
975 // now silence all unused outputs
976 if (has_midi_bypass ()) {
977 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
979 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
980 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
982 used_outputs.get (*t, out, &valid);
984 bufs.get (*t, out).silence (nframes, 0);
989 if (_match.method == Split) {
990 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
991 if (_configured_internal.get (*t) == 0) {
994 // copy/feeds _all_ *connected* inputs, copy the first buffer
996 uint32_t first_idx = in_map.get (*t, 0, &valid);
997 assert (valid && first_idx == 0); // check_inplace ensures this
998 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
999 uint32_t idx = in_map.get (*t, i, &valid);
1002 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0);
1008 // apply output map and/or monotonic but not identity i/o mappings
1009 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1010 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1012 uint32_t src_idx = out_map.get_src (*t, out, &valid);
1014 bufs.get (*t, out).silence (nframes, 0);
1017 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
1019 bufs.get (*t, out).silence (nframes, 0);
1022 if (in_idx != src_idx) {
1023 bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0);
1031 PluginInsert::silence (framecnt_t nframes, framepos_t start_frame)
1037 _delaybuffers.flush ();
1039 ChanMapping in_map (natural_input_streams ());
1040 ChanMapping out_map (natural_output_streams ());
1041 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
1043 if (is_channelstrip ()) {
1044 if (_configured_in.n_audio() > 0) {
1045 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
1049 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1050 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
1055 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, double speed, pframes_t nframes, bool)
1058 // collect sidechain input for complete cycle (!)
1059 // TODO we need delaylines here for latency compensation
1060 _sidechain->run (bufs, start_frame, end_frame, speed, nframes, true);
1063 if (_pending_active) {
1064 /* run as normal if we are active or moving from inactive to active */
1066 if (_session.transport_rolling() || _session.bounce_processing()) {
1067 automation_run (bufs, start_frame, end_frame, speed, nframes);
1069 connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, false);
1073 bypass (bufs, nframes);
1074 _delaybuffers.flush ();
1077 _active = _pending_active;
1079 /* we have no idea whether the plugin generated silence or not, so mark
1080 * all buffers appropriately.
1085 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes)
1087 Evoral::ControlEvent next_event (0, 0.0f);
1088 framecnt_t offset = 0;
1090 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1093 connect_and_run (bufs, start, end, speed, nframes, offset, false);
1097 if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1099 /* no events have a time within the relevant range */
1101 connect_and_run (bufs, start, end, speed, nframes, offset, true);
1107 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - start), (framecnt_t) nframes);
1109 connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed
1115 if (!find_next_event (start, end, next_event)) {
1120 /* cleanup anything that is left to do */
1123 connect_and_run (bufs, start, start + nframes, speed, nframes, offset, true);
1128 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1130 if (param.type() != PluginAutomation)
1133 if (_plugins.empty()) {
1134 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1136 abort(); /*NOTREACHED*/
1139 return _plugins[0]->default_value (param.id());
1144 PluginInsert::can_reset_all_parameters ()
1147 uint32_t params = 0;
1148 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1150 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1152 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1156 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1162 if (ac->automation_state() & Play) {
1167 return all && (params > 0);
1171 PluginInsert::reset_parameters_to_default ()
1175 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1177 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1179 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1183 const float dflt = _plugins[0]->default_value (cid);
1184 const float curr = _plugins[0]->get_parameter (cid);
1190 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1195 if (ac->automation_state() & Play) {
1200 ac->set_value (dflt, Controllable::NoGroup);
1205 boost::shared_ptr<Plugin>
1206 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1208 boost::shared_ptr<LadspaPlugin> lp;
1209 boost::shared_ptr<LuaProc> lua;
1211 boost::shared_ptr<LV2Plugin> lv2p;
1213 #ifdef WINDOWS_VST_SUPPORT
1214 boost::shared_ptr<WindowsVSTPlugin> vp;
1216 #ifdef LXVST_SUPPORT
1217 boost::shared_ptr<LXVSTPlugin> lxvp;
1219 #ifdef AUDIOUNIT_SUPPORT
1220 boost::shared_ptr<AUPlugin> ap;
1223 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1224 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1225 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1226 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1228 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1229 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1231 #ifdef WINDOWS_VST_SUPPORT
1232 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1233 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1235 #ifdef LXVST_SUPPORT
1236 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1237 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1239 #ifdef AUDIOUNIT_SUPPORT
1240 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1241 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1245 fatal << string_compose (_("programming error: %1"),
1246 X_("unknown plugin type in PluginInsert::plugin_factory"))
1248 abort(); /*NOTREACHED*/
1249 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1253 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1254 if (num < _in_map.size()) {
1255 bool changed = _in_map[num] != m;
1257 changed |= sanitize_maps ();
1259 PluginMapChanged (); /* EMIT SIGNAL */
1260 _mapping_changed = true;
1261 _session.set_dirty();
1267 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1268 if (num < _out_map.size()) {
1269 bool changed = _out_map[num] != m;
1271 changed |= sanitize_maps ();
1273 PluginMapChanged (); /* EMIT SIGNAL */
1274 _mapping_changed = true;
1275 _session.set_dirty();
1281 PluginInsert::set_thru_map (ChanMapping m) {
1282 bool changed = _thru_map != m;
1284 changed |= sanitize_maps ();
1286 PluginMapChanged (); /* EMIT SIGNAL */
1287 _mapping_changed = true;
1288 _session.set_dirty();
1293 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1294 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1296 if (_configured) { return false; }
1297 _configured_in = in;
1298 _configured_out = out;
1302 _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1307 PluginInsert::input_map () const
1311 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1312 ChanMapping m (i->second);
1313 const ChanMapping::Mappings& mp ((*i).second.mappings());
1314 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1315 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1316 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1325 PluginInsert::no_sc_input_map () const
1329 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1330 ChanMapping m (i->second);
1331 const ChanMapping::Mappings& mp ((*i).second.mappings());
1332 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1333 uint32_t ins = natural_input_streams().get(tm->first) - _cached_sidechain_pins.get(tm->first);
1334 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1335 if (i->second < ins) {
1336 rv.set (tm->first, i->first + pc * ins, i->second);
1345 PluginInsert::output_map () const
1349 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1350 ChanMapping m (i->second);
1351 const ChanMapping::Mappings& mp ((*i).second.mappings());
1352 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1353 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1354 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1358 if (has_midi_bypass ()) {
1359 rv.set (DataType::MIDI, 0, 0);
1366 PluginInsert::has_midi_bypass () const
1368 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1369 && natural_output_streams ().n_midi () == 0) {
1376 PluginInsert::has_midi_thru () const
1378 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1379 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1387 PluginInsert::is_channelstrip () const {
1388 return _plugins.front()->is_channelstrip();
1393 PluginInsert::check_inplace ()
1395 bool inplace_ok = !_plugins.front()->inplace_broken ();
1397 if (_thru_map.n_total () > 0) {
1398 // TODO once midi-bypass is part of the mapping, ignore it
1402 if (_match.method == Split && inplace_ok) {
1403 assert (get_count() == 1);
1404 assert (_in_map.size () == 1);
1405 if (!_out_map[0].is_monotonic ()) {
1408 if (_configured_internal != _configured_in) {
1409 /* no sidechain -- TODO we could allow this with
1410 * some more logic in PluginInsert::connect_and_run().
1412 * PluginInsert::reset_map() already maps it.
1417 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1418 if (_configured_internal.get (*t) == 0) {
1422 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1423 if (!valid || first_idx != 0) {
1424 // so far only allow to copy the *first* stream's buffer to others
1427 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1428 uint32_t idx = _in_map[0].get (*t, i, &valid);
1429 if (valid && idx != first_idx) {
1438 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1443 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1444 if (!_in_map[pc].is_monotonic ()) {
1447 if (!_out_map[pc].is_monotonic ()) {
1453 /* check if every output is fed by the corresponding input
1455 * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2
1456 * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1)
1458 * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
1460 ChanMapping in_map (input_map ());
1461 const ChanMapping::Mappings out_m (output_map ().mappings ());
1462 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1463 for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1464 /* src-pin: c->first, out-port: c->second */
1466 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1467 if (valid && in_port != c->second) {
1475 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1476 return !inplace_ok; // no-inplace
1480 PluginInsert::sanitize_maps ()
1482 bool changed = false;
1483 /* strip dead wood */
1484 PinMappings new_ins;
1485 PinMappings new_outs;
1486 ChanMapping new_thru;
1488 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1490 ChanMapping new_out;
1491 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1492 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1494 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1495 if (valid && idx < _configured_internal.get (*t)) {
1496 new_in.set (*t, i, idx);
1499 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1501 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1502 if (valid && idx < _configured_out.get (*t)) {
1503 new_out.set (*t, o, idx);
1507 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1510 new_ins[pc] = new_in;
1511 new_outs[pc] = new_out;
1514 /* prevent dup output assignments */
1515 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1516 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1517 bool mapped = false;
1518 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1520 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1521 if (valid && mapped) {
1522 new_outs[pc].unset (*t, idx);
1530 /* remove excess thru */
1531 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1532 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1534 uint32_t idx = _thru_map.get (*t, o, &valid);
1535 if (valid && idx < _configured_internal.get (*t)) {
1536 new_thru.set (*t, o, idx);
1541 /* prevent out + thru, existing plugin outputs override thru */
1542 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1543 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1544 bool mapped = false;
1546 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1547 new_outs[pc].get_src (*t, o, &mapped);
1548 if (mapped) { break; }
1550 if (!mapped) { continue; }
1551 uint32_t idx = new_thru.get (*t, o, &valid);
1553 new_thru.unset (*t, idx);
1558 if (has_midi_bypass ()) {
1559 // TODO: include midi-bypass in the thru set,
1560 // remove dedicated handling.
1561 new_thru.unset (DataType::MIDI, 0);
1564 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1568 _out_map = new_outs;
1569 _thru_map = new_thru;
1575 PluginInsert::reset_map (bool emit)
1577 const PinMappings old_in (_in_map);
1578 const PinMappings old_out (_out_map);
1582 _thru_map = ChanMapping ();
1584 /* build input map */
1585 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1586 uint32_t sc = 0; // side-chain round-robin (all instances)
1588 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1589 const uint32_t nis = natural_input_streams ().get(*t);
1590 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1592 /* SC inputs are last in the plugin-insert.. */
1593 const uint32_t sc_start = _configured_in.get (*t);
1594 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1595 /* ...but may not be at the end of the plugin ports.
1596 * in case the side-chain is not the last port, shift connections back.
1597 * and connect to side-chain
1600 uint32_t ic = 0; // split inputs
1601 const uint32_t cend = _configured_in.get (*t);
1603 for (uint32_t in = 0; in < nis; ++in) {
1604 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1605 if (iod.is_sidechain) {
1606 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1607 if (sc_len > 0) {// side-chain may be hidden
1608 _in_map[pc].set (*t, in, sc_start + sc);
1609 sc = (sc + 1) % sc_len;
1613 if (_match.method == Split) {
1614 if (cend == 0) { continue; }
1615 if (_strict_io && ic + stride * pc >= cend) {
1618 /* connect *no* sidechain sinks in round-robin fashion */
1619 _in_map[pc].set (*t, in, ic + stride * pc);
1620 if (_strict_io && (ic + 1) == cend) {
1623 ic = (ic + 1) % cend;
1625 uint32_t s = in - shift;
1626 if (stride * pc + s < cend) {
1627 _in_map[pc].set (*t, in, s + stride * pc);
1635 /* build output map */
1637 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1638 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1639 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1640 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1645 if (old_in == _in_map && old_out == _out_map) {
1649 PluginMapChanged (); /* EMIT SIGNAL */
1650 _mapping_changed = true;
1651 _session.set_dirty();
1657 PluginInsert::configure_io (ChanCount in, ChanCount out)
1659 Match old_match = _match;
1661 ChanCount old_internal;
1665 old_pins = natural_input_streams();
1666 old_in = _configured_in;
1667 old_out = _configured_out;
1668 old_internal = _configured_internal;
1670 _configured_in = in;
1671 _configured_internal = in;
1672 _configured_out = out;
1675 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1676 * (currently _sidechain->configure_io always succeeds
1677 * since Processor::configure_io() succeeds)
1679 if (!_sidechain->configure_io (in, out)) {
1680 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1683 _configured_internal += _sidechain->input()->n_ports();
1685 // include (static_cast<Route*>owner())->name() ??
1686 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1689 /* get plugin configuration */
1690 _match = private_can_support_io_configuration (in, out);
1692 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1694 DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
1695 DEBUG_STR_APPEND(a, _match);
1696 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1700 /* set the matching method and number of plugins that we will use to meet this configuration */
1701 if (set_count (_match.plugins) == false) {
1702 PluginIoReConfigure (); /* EMIT SIGNAL */
1703 _configured = false;
1707 /* configure plugins */
1708 switch (_match.method) {
1711 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1712 PluginIoReConfigure (); /* EMIT SIGNAL */
1713 _configured = false;
1719 ChanCount din (_configured_internal);
1720 ChanCount dout (din); // hint
1722 if (_custom_sinks.n_total () > 0) {
1723 din = _custom_sinks;
1726 } else if (_preset_out.n_audio () > 0) {
1727 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1728 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1729 dout.set (DataType::AUDIO, 2);
1731 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1733 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1734 bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1736 if (useins.n_audio() == 0) {
1739 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1741 if (_plugins.front()->configure_io (useins, dout) == false) {
1742 PluginIoReConfigure (); /* EMIT SIGNAL */
1743 _configured = false;
1747 _custom_sinks = din;
1752 if (_plugins.front()->configure_io (in, out) == false) {
1753 PluginIoReConfigure (); /* EMIT SIGNAL */
1754 _configured = false;
1760 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",
1762 _configured ? "Y" : "N",
1763 _maps_from_state ? "Y" : "N",
1764 old_in == in ? "==" : "!=",
1765 old_out == out ? "==" : "!=",
1766 old_pins == natural_input_streams () ? "==" : "!=",
1767 old_match.method == _match.method ? "==" : "!=",
1768 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1769 _in_map.size() == get_count () ? "==" : "!=",
1770 _out_map.size() == get_count () ? "==" : "!="
1773 bool mapping_changed = false;
1774 if (old_in == in && old_out == out
1776 && old_pins == natural_input_streams ()
1777 && old_match.method == _match.method
1778 && old_match.custom_cfg == _match.custom_cfg
1779 && _in_map.size() == _out_map.size()
1780 && _in_map.size() == get_count ()
1782 assert (_maps_from_state == false);
1783 /* If the configuration has not changed, keep the mapping */
1784 mapping_changed = sanitize_maps ();
1785 } else if (_match.custom_cfg && _configured) {
1786 assert (_maps_from_state == false);
1787 /* don't touch the map in manual mode */
1788 mapping_changed = sanitize_maps ();
1791 if (is_channelstrip ()) {
1792 /* fake channel map - for wire display */
1795 _thru_map = ChanMapping ();
1796 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1797 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1798 /* set "thru" map for in-place forward of audio */
1799 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1800 _thru_map.set (DataType::AUDIO, i, i);
1802 /* and midi (after implicit 1st channel bypass) */
1803 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1804 _thru_map.set (DataType::MIDI, i, i);
1808 if (_maps_from_state && old_in == in && old_out == out) {
1809 mapping_changed = true;
1812 /* generate a new mapping */
1813 mapping_changed = reset_map (false);
1815 _maps_from_state = false;
1818 if (mapping_changed) {
1819 PluginMapChanged (); /* EMIT SIGNAL */
1822 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1825 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1826 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1828 DEBUG_STR_APPEND(a, "----><----\n");
1830 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1831 DEBUG_STR_APPEND(a, " * Inputs:\n");
1832 DEBUG_STR_APPEND(a, _in_map[pc]);
1833 DEBUG_STR_APPEND(a, " * Outputs:\n");
1834 DEBUG_STR_APPEND(a, _out_map[pc]);
1836 DEBUG_STR_APPEND(a, " * Thru:\n");
1837 DEBUG_STR_APPEND(a, _thru_map);
1838 DEBUG_STR_APPEND(a, "-------->>--------\n");
1839 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1844 _no_inplace = check_inplace ();
1845 _mapping_changed = false;
1847 /* only the "noinplace_buffers" thread buffers need to be this large,
1848 * this can be optimized. other buffers are fine with
1849 * ChanCount::max (natural_input_streams (), natural_output_streams())
1850 * and route.cc's max (configured_in, configured_out)
1852 * no-inplace copies "thru" outputs (to emulate in-place) for
1853 * all outputs (to prevent overwrite) into a temporary space
1854 * which also holds input buffers (in case the plugin does process
1855 * in-place and overwrites those).
1857 * this buffers need to be at least as
1858 * natural_input_streams () + possible outputs.
1860 * sidechain inputs add a constraint on the input:
1861 * configured input + sidechain (=_configured_internal)
1863 * NB. this also satisfies
1864 * max (natural_input_streams(), natural_output_streams())
1865 * which is needed for silence runs
1867 _required_buffers = ChanCount::max (_configured_internal,
1868 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1870 if (old_in != in || old_out != out || old_internal != _configured_internal
1871 || old_pins != natural_input_streams ()
1872 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1874 PluginIoReConfigure (); /* EMIT SIGNAL */
1877 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1878 _latency_changed = true;
1880 // we don't know the analysis window size, so we must work with the
1881 // current buffer size here. each request for data fills in these
1882 // buffers and the analyser makes sure it gets enough data for the
1884 session().ensure_buffer_set (_signal_analysis_inputs, in);
1885 _signal_analysis_inputs.set_count (in);
1887 session().ensure_buffer_set (_signal_analysis_outputs, out);
1888 _signal_analysis_outputs.set_count (out);
1890 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1893 return Processor::configure_io (in, out);
1896 /** Decide whether this PluginInsert can support a given IO configuration.
1897 * To do this, we run through a set of possible solutions in rough order of
1900 * @param in Required input channel count.
1901 * @param out Filled in with the output channel count if we return true.
1902 * @return true if the given IO configuration can be supported.
1905 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1908 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1910 return private_can_support_io_configuration (in, out).method != Impossible;
1914 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1916 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1917 // preseed hint (for variable i/o)
1918 out.set (DataType::AUDIO, _preset_out.n_audio ());
1921 Match rv = internal_can_support_io_configuration (in, out);
1923 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1924 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
1925 out.set (DataType::AUDIO, _preset_out.n_audio ());
1930 /** A private version of can_support_io_configuration which returns the method
1931 * by which the configuration can be matched, rather than just whether or not
1935 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1937 if (_plugins.empty()) {
1942 if (is_channelstrip ()) {
1944 return Match (ExactMatch, 1);
1948 /* if a user specified a custom cfg, so be it. */
1950 PluginInfoPtr info = _plugins.front()->get_info();
1952 if (info->reconfigurable_io()) {
1953 return Match (Delegate, 1, _strict_io, true);
1955 return Match (ExactMatch, get_count(), _strict_io, true);
1959 /* try automatic configuration */
1960 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1962 PluginInfoPtr info = _plugins.front()->get_info();
1963 ChanCount inputs = info->n_inputs;
1964 ChanCount outputs = info->n_outputs;
1966 /* handle case strict-i/o */
1967 if (_strict_io && m.method != Impossible) {
1970 /* special case MIDI instruments */
1971 if (needs_midi_input ()) {
1972 // output = midi-bypass + at most master-out channels.
1973 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1974 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1975 out = ChanCount::min (out, max_out);
1976 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
1982 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1983 /* replicate processor to match output count (generators and such)
1984 * at least enough to feed every output port. */
1985 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1986 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1987 uint32_t nout = outputs.get (*t);
1988 if (nout == 0 || inx.get(*t) == 0) { continue; }
1989 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1992 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
1993 return Match (Replicate, f, _strict_io);
2004 if (m.method != Impossible) {
2008 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2010 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
2012 if (info->reconfigurable_io()) {
2015 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2016 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2017 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
2019 // houston, we have a problem.
2020 return Match (Impossible, 0);
2023 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2024 return Match (Delegate, 1, _strict_io);
2027 ChanCount midi_bypass;
2028 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2029 midi_bypass.set (DataType::MIDI, 1);
2032 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
2034 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2035 uint32_t nin = ns_inputs.get (*t);
2036 uint32_t nout = outputs.get (*t);
2037 if (nin == 0 || inx.get(*t) == 0) { continue; }
2038 // prefer floor() so the count won't overly increase IFF (nin < nout)
2039 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
2041 if (f > 0 && outputs * f >= _configured_out) {
2042 out = outputs * f + midi_bypass;
2043 return Match (Replicate, f, _strict_io);
2046 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
2048 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2049 uint32_t nin = ns_inputs.get (*t);
2050 if (nin == 0 || inx.get(*t) == 0) { continue; }
2051 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2054 out = outputs * f + midi_bypass;
2055 return Match (Replicate, f, _strict_io);
2058 // add at least as many plugins needed to connect all inputs
2060 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2061 uint32_t nin = inputs.get (*t);
2062 if (nin == 0 || inx.get(*t) == 0) { continue; }
2063 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2065 out = outputs * f + midi_bypass;
2066 return Match (Replicate, f, _strict_io);
2069 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
2071 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
2073 if (_plugins.empty()) {
2077 PluginInfoPtr info = _plugins.front()->get_info();
2078 ChanCount in; in += inx;
2079 ChanCount midi_bypass;
2081 if (info->reconfigurable_io()) {
2082 /* Plugin has flexible I/O, so delegate to it
2083 * pre-seed outputs, plugin tries closest match
2086 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2087 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2088 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
2090 return Match (Impossible, 0);
2093 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2094 return Match (Delegate, 1);
2097 ChanCount inputs = info->n_inputs;
2098 ChanCount outputs = info->n_outputs;
2099 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2101 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2102 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
2103 midi_bypass.set (DataType::MIDI, 1);
2105 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
2106 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
2107 in.set(DataType::MIDI, 0);
2110 // add internally provided sidechain ports
2111 ChanCount insc = in + sidechain_input_ports ();
2113 bool no_inputs = true;
2114 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2115 if (inputs.get (*t) != 0) {
2122 /* no inputs so we can take any input configuration since we throw it away */
2123 out = outputs + midi_bypass;
2124 return Match (NoInputs, 1);
2127 /* Plugin inputs match requested inputs + side-chain-ports exactly */
2128 if (inputs == insc) {
2129 out = outputs + midi_bypass;
2130 return Match (ExactMatch, 1);
2133 /* Plugin inputs matches without side-chain-pins */
2134 if (ns_inputs == in) {
2135 out = outputs + midi_bypass;
2136 return Match (ExactMatch, 1);
2139 /* We may be able to run more than one copy of the plugin within this insert
2140 to cope with the insert having more inputs than the plugin.
2141 We allow replication only for plugins with either zero or 1 inputs and outputs
2142 for every valid data type.
2146 bool can_replicate = true;
2147 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
2149 // ignore side-chains
2150 uint32_t nin = ns_inputs.get (*t);
2152 // No inputs of this type
2153 if (nin == 0 && in.get(*t) == 0) {
2157 if (nin != 1 || outputs.get (*t) != 1) {
2158 can_replicate = false;
2162 // Potential factor not set yet
2164 f = in.get(*t) / nin;
2167 // Factor for this type does not match another type, can not replicate
2168 if (f != (in.get(*t) / nin)) {
2169 can_replicate = false;
2174 if (can_replicate && f > 0) {
2175 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2176 out.set (*t, outputs.get(*t) * f);
2179 return Match (Replicate, f);
2182 /* If the processor has exactly one input of a given type, and
2183 the plugin has more, we can feed the single processor input
2184 to some or all of the plugin inputs. This is rather
2185 special-case-y, but the 1-to-many case is by far the
2186 simplest. How do I split thy 2 processor inputs to 3
2187 plugin inputs? Let me count the ways ...
2190 bool can_split = true;
2191 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2193 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2194 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2196 if (!can_split_type && !nothing_to_do_for_type) {
2202 out = outputs + midi_bypass;
2203 return Match (Split, 1);
2206 /* If the plugin has more inputs than we want, we can `hide' some of them
2207 by feeding them silence.
2210 bool could_hide = false;
2211 bool cannot_hide = false;
2212 ChanCount hide_channels;
2214 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2215 if (inputs.get(*t) > in.get(*t)) {
2216 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2217 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2219 } else if (inputs.get(*t) < in.get(*t)) {
2220 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2225 if (could_hide && !cannot_hide) {
2226 out = outputs + midi_bypass;
2227 return Match (Hide, 1, false, false, hide_channels);
2230 return Match (Impossible, 0);
2235 PluginInsert::get_state ()
2237 return state (true);
2241 PluginInsert::state (bool full)
2243 XMLNode& node = Processor::state (full);
2245 node.add_property("type", _plugins[0]->state_node_name());
2246 node.add_property("unique-id", _plugins[0]->unique_id());
2247 node.add_property("count", string_compose("%1", _plugins.size()));
2249 /* remember actual i/o configuration (for later placeholder
2250 * in case the plugin goes missing) */
2251 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2252 node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2253 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2254 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2256 /* save custom i/o config */
2257 node.add_property("custom", _custom_cfg ? "yes" : "no");
2258 for (uint32_t pc = 0; pc < get_count(); ++pc) {
2260 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2261 node.add_child_nocopy (* _in_map[pc].state (tmp));
2262 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2263 node.add_child_nocopy (* _out_map[pc].state (tmp));
2265 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2268 node.add_child_nocopy (_sidechain->state (full));
2271 _plugins[0]->set_insert_id(this->id());
2272 node.add_child_nocopy (_plugins[0]->get_state());
2274 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2275 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2277 node.add_child_nocopy (ac->get_state());
2285 PluginInsert::set_control_ids (const XMLNode& node, int version)
2287 const XMLNodeList& nlist = node.children();
2288 XMLNodeConstIterator iter;
2289 set<Evoral::Parameter>::const_iterator p;
2291 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2292 if ((*iter)->name() == Controllable::xml_node_name) {
2293 XMLProperty const * prop;
2295 uint32_t p = (uint32_t)-1;
2297 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
2298 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2300 p = lv2plugin->port_index(prop->value().c_str());
2304 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
2305 p = atoi (prop->value());
2308 if (p != (uint32_t)-1) {
2310 /* this may create the new controllable */
2312 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2314 #ifndef NO_PLUGIN_STATE
2318 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2320 ac->set_state (**iter, version);
2329 PluginInsert::set_state(const XMLNode& node, int version)
2331 XMLNodeList nlist = node.children();
2332 XMLNodeIterator niter;
2333 XMLPropertyList plist;
2334 XMLProperty const * prop;
2335 ARDOUR::PluginType type;
2337 if ((prop = node.property ("type")) == 0) {
2338 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2342 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2343 type = ARDOUR::LADSPA;
2344 } else if (prop->value() == X_("lv2")) {
2346 } else if (prop->value() == X_("windows-vst")) {
2347 type = ARDOUR::Windows_VST;
2348 } else if (prop->value() == X_("lxvst")) {
2349 type = ARDOUR::LXVST;
2350 } else if (prop->value() == X_("audiounit")) {
2351 type = ARDOUR::AudioUnit;
2352 } else if (prop->value() == X_("luaproc")) {
2355 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2361 prop = node.property ("unique-id");
2364 #ifdef WINDOWS_VST_SUPPORT
2365 /* older sessions contain VST plugins with only an "id" field.
2368 if (type == ARDOUR::Windows_VST) {
2369 prop = node.property ("id");
2373 #ifdef LXVST_SUPPORT
2374 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2376 if (type == ARDOUR::LXVST) {
2377 prop = node.property ("id");
2383 error << _("Plugin has no unique ID field") << endmsg;
2388 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2390 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2391 * allow to move sessions windows <> linux */
2392 #ifdef LXVST_SUPPORT
2393 if (plugin == 0 && type == ARDOUR::Windows_VST) {
2394 type = ARDOUR::LXVST;
2395 plugin = find_plugin (_session, prop->value(), type);
2399 #ifdef WINDOWS_VST_SUPPORT
2400 if (plugin == 0 && type == ARDOUR::LXVST) {
2401 type = ARDOUR::Windows_VST;
2402 plugin = find_plugin (_session, prop->value(), type);
2406 if (plugin == 0 && type == ARDOUR::Lua) {
2407 /* unique ID (sha1 of script) was not found,
2408 * load the plugin from the serialized version in the
2409 * session-file instead.
2411 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2412 XMLNode *ls = node.child (lp->state_node_name().c_str());
2414 lp->set_script_from_state (*ls);
2420 error << string_compose(
2421 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2422 "Perhaps it was removed or moved since it was last used."),
2428 // The name of the PluginInsert comes from the plugin, nothing else
2429 _name = plugin->get_info()->name;
2433 // Processor::set_state() will set this, but too late
2434 // for it to be available when setting up plugin
2435 // state. We can't call Processor::set_state() until
2436 // the plugins themselves are created and added.
2440 if (_plugins.empty()) {
2441 /* if we are adding the first plugin, we will need to set
2442 up automatable controls.
2444 add_plugin (plugin);
2445 create_automatable_parameters ();
2446 set_control_ids (node, version);
2449 if ((prop = node.property ("count")) != 0) {
2450 sscanf (prop->value().c_str(), "%u", &count);
2453 if (_plugins.size() != count) {
2454 for (uint32_t n = 1; n < count; ++n) {
2455 add_plugin (plugin_factory (plugin));
2459 Processor::set_state (node, version);
2461 PBD::ID new_id = this->id();
2462 PBD::ID old_id = this->id();
2464 if ((prop = node.property ("id")) != 0) {
2465 old_id = prop->value ();
2468 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2470 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2471 and set all plugins to the same state.
2474 if ((*niter)->name() == plugin->state_node_name()) {
2476 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2477 /* Plugin state can include external files which are named after the ID.
2479 * If regenerate_xml_or_string_ids() is set, the ID will already have
2480 * been changed, so we need to use the old ID from the XML to load the
2481 * state and then update the ID.
2483 * When copying a plugin-state, route_ui takes care of of updating the ID,
2484 * but we need to call set_insert_id() to clear the cached plugin-state
2485 * and force a change.
2487 if (!regenerate_xml_or_string_ids ()) {
2488 (*i)->set_insert_id (new_id);
2490 (*i)->set_insert_id (old_id);
2493 (*i)->set_state (**niter, version);
2495 if (regenerate_xml_or_string_ids ()) {
2496 (*i)->set_insert_id (new_id);
2504 if (version < 3000) {
2506 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2507 this is all handled by Automatable
2510 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2511 if ((*niter)->name() == "Redirect") {
2512 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2513 Processor::set_state (**niter, version);
2518 set_parameter_state_2X (node, version);
2521 if ((prop = node.property (X_("custom"))) != 0) {
2522 _custom_cfg = string_is_affirmative (prop->value());
2525 uint32_t in_maps = 0;
2526 uint32_t out_maps = 0;
2527 XMLNodeList kids = node.children ();
2528 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2529 if ((*i)->name() == X_("ConfiguredInput")) {
2530 _configured_in = ChanCount(**i);
2532 if ((*i)->name() == X_("CustomSinks")) {
2533 _custom_sinks = ChanCount(**i);
2535 if ((*i)->name() == X_("ConfiguredOutput")) {
2536 _custom_out = ChanCount(**i);
2537 _configured_out = ChanCount(**i);
2539 if ((*i)->name() == X_("PresetOutput")) {
2540 _preset_out = ChanCount(**i);
2542 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2543 long pc = atol (&((*i)->name().c_str()[9]));
2544 if (pc >= 0 && pc <= (long) get_count()) {
2545 _in_map[pc] = ChanMapping (**i);
2549 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2550 long pc = atol (&((*i)->name().c_str()[10]));
2551 if (pc >= 0 && pc <= (long) get_count()) {
2552 _out_map[pc] = ChanMapping (**i);
2556 if ((*i)->name () == "ThruMap") {
2557 _thru_map = ChanMapping (**i);
2560 // sidechain is a Processor (IO)
2561 if ((*i)->name () == Processor::state_node_name) {
2565 _sidechain->set_state (**i, version);
2569 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2570 _maps_from_state = true;
2573 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2577 (*i)->deactivate ();
2581 PluginConfigChanged (); /* EMIT SIGNAL */
2586 PluginInsert::update_id (PBD::ID id)
2589 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2590 (*i)->set_insert_id (id);
2595 PluginInsert::set_state_dir (const std::string& d)
2597 // state() only saves the state of the first plugin
2598 _plugins[0]->set_state_dir (d);
2602 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2604 XMLNodeList nlist = node.children();
2605 XMLNodeIterator niter;
2607 /* look for port automation node */
2609 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2611 if ((*niter)->name() != port_automation_node_name) {
2616 XMLProperty const * cprop;
2617 XMLNodeConstIterator iter;
2622 cnodes = (*niter)->children ("port");
2624 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2628 if ((cprop = child->property("number")) != 0) {
2629 port = cprop->value().c_str();
2631 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2635 sscanf (port, "%" PRIu32, &port_id);
2637 if (port_id >= _plugins[0]->parameter_count()) {
2638 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2642 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2643 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2645 if (c && c->alist()) {
2646 if (!child->children().empty()) {
2647 c->alist()->set_state (*child->children().front(), version);
2649 /* In some cases 2.X saves lists with min_yval and max_yval
2650 being FLT_MIN and FLT_MAX respectively. This causes problems
2651 in A3 because these min/max values are used to compute
2652 where GUI control points should be drawn. If we see such
2653 values, `correct' them to the min/max of the appropriate
2657 float min_y = c->alist()->get_min_y ();
2658 float max_y = c->alist()->get_max_y ();
2660 ParameterDescriptor desc;
2661 _plugins.front()->get_parameter_descriptor (port_id, desc);
2663 if (min_y == FLT_MIN) {
2667 if (max_y == FLT_MAX) {
2671 c->alist()->set_yrange (min_y, max_y);
2674 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2686 PluginInsert::describe_parameter (Evoral::Parameter param)
2688 if (param.type() == PluginAutomation) {
2689 return _plugins[0]->describe_parameter (param);
2690 } else if (param.type() == PluginPropertyAutomation) {
2691 boost::shared_ptr<AutomationControl> c(automation_control(param));
2692 if (c && !c->desc().label.empty()) {
2693 return c->desc().label;
2696 return Automatable::describe_parameter(param);
2700 PluginInsert::signal_latency() const
2702 if (_user_latency) {
2703 return _user_latency;
2706 return _plugins[0]->signal_latency ();
2710 PluginInsert::type ()
2712 return plugin()->get_info()->type;
2715 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2716 const Evoral::Parameter& param,
2717 const ParameterDescriptor& desc,
2718 boost::shared_ptr<AutomationList> list)
2719 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2723 alist()->reset_default (desc.normal);
2725 list->set_interpolation(Evoral::ControlList::Discrete);
2730 /** @param val `user' value */
2733 PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2735 /* FIXME: probably should be taking out some lock here.. */
2737 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2738 (*i)->set_parameter (_list->parameter().id(), user_val);
2741 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2743 iasp->set_parameter (_list->parameter().id(), user_val);
2746 AutomationControl::actually_set_value (user_val, group_override);
2750 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2752 AutomationControl::actually_set_value (user_val, Controllable::NoGroup);
2756 PluginInsert::PluginControl::get_state ()
2760 XMLNode& node (AutomationControl::get_state());
2761 ss << parameter().id();
2762 node.add_property (X_("parameter"), ss.str());
2764 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2766 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2773 /** @return `user' val */
2775 PluginInsert::PluginControl::get_value () const
2777 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2783 return plugin->get_parameter (_list->parameter().id());
2786 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2787 const Evoral::Parameter& param,
2788 const ParameterDescriptor& desc,
2789 boost::shared_ptr<AutomationList> list)
2790 : AutomationControl (p->session(), param, desc, list)
2794 alist()->set_yrange (desc.lower, desc.upper);
2795 alist()->reset_default (desc.normal);
2800 PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd)
2802 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2803 This is lossy, but better than nothing until Ardour's automation system
2804 can handle various datatypes all the way down. */
2805 const Variant value(_desc.datatype, user_val);
2806 if (value.type() == Variant::NOTHING) {
2807 error << "set_value(double) called for non-numeric property" << endmsg;
2811 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2812 (*i)->set_property(_list->parameter().id(), value);
2817 AutomationControl::actually_set_value (user_val, gcd);
2821 PluginInsert::PluginPropertyControl::get_state ()
2825 XMLNode& node (AutomationControl::get_state());
2826 ss << parameter().id();
2827 node.add_property (X_("property"), ss.str());
2828 node.remove_property (X_("value"));
2834 PluginInsert::PluginPropertyControl::get_value () const
2836 return _value.to_double();
2839 boost::shared_ptr<Plugin>
2840 PluginInsert::get_impulse_analysis_plugin()
2842 boost::shared_ptr<Plugin> ret;
2843 if (_impulseAnalysisPlugin.expired()) {
2844 // LV2 in particular uses various _session params
2845 // during init() -- most notably block_size..
2847 ret = plugin_factory(_plugins[0]);
2848 ret->configure_io (internal_input_streams (), internal_output_streams ());
2849 _impulseAnalysisPlugin = ret;
2851 ret = _impulseAnalysisPlugin.lock();
2858 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2860 // called from outside the audio thread, so this should be safe
2861 // only do audio as analysis is (currently) only for audio plugins
2862 _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes);
2863 _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
2865 _signal_analysis_collected_nframes = 0;
2866 _signal_analysis_collect_nframes_max = nframes;
2869 /** Add a plugin to our list */
2871 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2873 plugin->set_insert_id (this->id());
2875 if (_plugins.empty()) {
2876 /* first (and probably only) plugin instance - connect to relevant signals */
2878 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2879 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2880 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2881 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2882 _custom_sinks = plugin->get_info()->n_inputs;
2883 // cache sidechain port count
2884 _cached_sidechain_pins.reset ();
2885 const ChanCount& nis (plugin->get_info()->n_inputs);
2886 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2887 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2888 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2889 if (iod.is_sidechain) {
2890 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2895 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2896 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2898 vst->set_insert (this, _plugins.size ());
2902 _plugins.push_back (plugin);
2906 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
2909 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2910 if (! (*i)->load_preset (pr)) {
2918 PluginInsert::realtime_handle_transport_stopped ()
2920 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2921 (*i)->realtime_handle_transport_stopped ();
2926 PluginInsert::realtime_locate ()
2928 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2929 (*i)->realtime_locate ();
2934 PluginInsert::monitoring_changed ()
2936 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2937 (*i)->monitoring_changed ();
2942 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2944 // this is called in RT context, LatencyChanged is emitted after run()
2945 _latency_changed = true;
2949 PluginInsert::start_touch (uint32_t param_id)
2951 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2953 ac->start_touch (session().audible_frame());
2958 PluginInsert::end_touch (uint32_t param_id)
2960 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2962 ac->stop_touch (true, session().audible_frame());
2966 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2969 case PluginInsert::Impossible: o << "Impossible"; break;
2970 case PluginInsert::Delegate: o << "Delegate"; break;
2971 case PluginInsert::NoInputs: o << "NoInputs"; break;
2972 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2973 case PluginInsert::Replicate: o << "Replicate"; break;
2974 case PluginInsert::Split: o << "Split"; break;
2975 case PluginInsert::Hide: o << "Hide"; break;
2977 o << " cnt: " << m.plugins
2978 << (m.strict_io ? " strict-io" : "")
2979 << (m.custom_cfg ? " custom-cfg" : "");
2980 if (m.method == PluginInsert::Hide) {
2981 o << " hide: " << m.hide;