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/types_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"
54 #include "ardour/mac_vst_plugin.h"
57 #ifdef AUDIOUNIT_SUPPORT
58 #include "ardour/audio_unit.h"
61 #include "ardour/session.h"
62 #include "ardour/types.h"
67 using namespace ARDOUR;
70 const string PluginInsert::port_automation_node_name = "PortAutomation";
72 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
73 : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
74 , _sc_playback_latency (0)
75 , _sc_capture_latency (0)
76 , _plugin_signal_latency (0)
77 , _signal_analysis_collected_nframes(0)
78 , _signal_analysis_collect_nframes_max(0)
83 , _maps_from_state (false)
84 , _latency_changed (false)
85 , _bypass_port (UINT32_MAX)
87 /* the first is the master */
91 create_automatable_parameters ();
92 const ChanCount& sc (sidechain_input_pins ());
93 if (sc.n_audio () > 0 || sc.n_midi () > 0) {
94 add_sidechain (sc.n_audio (), sc.n_midi ());
99 PluginInsert::~PluginInsert ()
101 for (CtrlOutMap::const_iterator i = _control_outputs.begin(); i != _control_outputs.end(); ++i) {
102 boost::dynamic_pointer_cast<ReadOnlyControl>(i->second)->drop_references ();
107 PluginInsert::set_strict_io (bool b)
109 bool changed = _strict_io != b;
112 PluginConfigChanged (); /* EMIT SIGNAL */
117 PluginInsert::set_count (uint32_t num)
119 bool require_state = !_plugins.empty();
121 if (require_state && num > 1 && plugin (0)->get_info ()->type == ARDOUR::AudioUnit) {
122 // we don't allow to replicate AUs
126 /* this is a bad idea.... we shouldn't do this while active.
127 * only a route holding their redirect_lock should be calling this
132 } else if (num > _plugins.size()) {
133 uint32_t diff = num - _plugins.size();
135 for (uint32_t n = 0; n < diff; ++n) {
136 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
140 XMLNode& state = _plugins[0]->get_state ();
141 p->set_state (state, Stateful::loading_state_version);
148 PluginConfigChanged (); /* EMIT SIGNAL */
150 } else if (num < _plugins.size()) {
151 uint32_t diff = _plugins.size() - num;
152 for (uint32_t n= 0; n < diff; ++n) {
155 PluginConfigChanged (); /* EMIT SIGNAL */
163 PluginInsert::set_sinks (const ChanCount& c)
166 /* no signal, change will only be visible after re-config */
170 PluginInsert::set_outputs (const ChanCount& c)
172 bool changed = (_custom_out != c) && _custom_cfg;
175 PluginConfigChanged (); /* EMIT SIGNAL */
180 PluginInsert::set_custom_cfg (bool b)
182 bool changed = _custom_cfg != b;
185 PluginConfigChanged (); /* EMIT SIGNAL */
190 PluginInsert::set_preset_out (const ChanCount& c)
192 bool changed = _preset_out != c;
194 if (changed && !_custom_cfg) {
195 PluginConfigChanged (); /* EMIT SIGNAL */
201 PluginInsert::add_sidechain (uint32_t n_audio, uint32_t n_midi)
203 // caller must hold process lock
207 std::ostringstream n;
208 if (n_audio > 0 || n_midi > 0) {
209 n << "Sidechain " << Session::next_name_id ();
211 n << "TO BE RESET FROM XML";
213 SideChain *sc = new SideChain (_session, n.str ());
214 _sidechain = boost::shared_ptr<SideChain> (sc);
215 _sidechain->activate ();
216 for (uint32_t n = 0; n < n_audio; ++n) {
217 _sidechain->input()->add_port ("", owner(), DataType::AUDIO); // add a port, don't connect.
219 for (uint32_t n = 0; n < n_midi; ++n) {
220 _sidechain->input()->add_port ("", owner(), DataType::MIDI); // add a port, don't connect.
222 PluginConfigChanged (); /* EMIT SIGNAL */
227 PluginInsert::del_sidechain ()
233 _sc_playback_latency = 0;
234 _sc_capture_latency = 0;
235 PluginConfigChanged (); /* EMIT SIGNAL */
240 PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback)
243 (_sc_playback_latency != playback || _sc_capture_latency != capture)) {
244 _sc_capture_latency = capture;
245 _sc_playback_latency = playback;
246 LatencyRange pl; pl.min = pl.max = playback;
247 LatencyRange cl; cl.min = cl.max = capture;
248 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback));
249 PortSet& ps (_sidechain->input ()->ports ());
250 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
251 p->set_private_latency_range (pl, true);
252 p->set_private_latency_range (cl, false);
258 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
260 if (which.type() != PluginAutomation)
263 boost::shared_ptr<AutomationControl> c
264 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
267 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_sample()));
272 PluginInsert::output_streams() const
274 assert (_configured);
275 return _configured_out;
279 PluginInsert::input_streams() const
281 assert (_configured);
282 return _configured_in;
286 PluginInsert::internal_streams() const
288 assert (_configured);
289 return _configured_internal;
293 PluginInsert::internal_output_streams() const
295 assert (!_plugins.empty());
297 PluginInfoPtr info = _plugins.front()->get_info();
299 if (info->reconfigurable_io()) {
300 ChanCount out = _plugins.front()->output_streams ();
301 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
304 ChanCount out = info->n_outputs;
305 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
306 out.set_audio (out.n_audio() * _plugins.size());
307 out.set_midi (out.n_midi() * _plugins.size());
313 PluginInsert::internal_input_streams() const
315 assert (!_plugins.empty());
319 PluginInfoPtr info = _plugins.front()->get_info();
321 if (info->reconfigurable_io()) {
322 in = _plugins.front()->input_streams();
327 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
329 if (_match.method == Split) {
331 /* we are splitting 1 processor input to multiple plugin inputs,
332 so we have a maximum of 1 stream of each type.
334 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
335 if (in.get (*t) > 1) {
341 } else if (_match.method == Hide) {
343 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
344 in.set (*t, in.get (*t) - _match.hide.get (*t));
350 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
351 in.set (*t, in.get (*t) * _plugins.size ());
359 PluginInsert::natural_output_streams() const
362 if (is_channelstrip ()) {
363 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
366 return _plugins[0]->get_info()->n_outputs;
370 PluginInsert::natural_input_streams() const
373 if (is_channelstrip ()) {
374 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
377 return _plugins[0]->get_info()->n_inputs;
381 PluginInsert::sidechain_input_pins() const
383 return _cached_sidechain_pins;
387 PluginInsert::has_no_inputs() const
389 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
393 PluginInsert::has_no_audio_inputs() const
395 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
399 PluginInsert::plugin_latency () const {
400 return _plugins.front()->signal_latency ();
404 PluginInsert::is_instrument() const
406 PluginInfoPtr pip = _plugins[0]->get_info();
407 if (pip->is_instrument ()) {
410 return pip->n_inputs.n_midi () != 0 && pip->n_outputs.n_audio () > 0 && pip->n_inputs.n_audio () == 0;
414 PluginInsert::has_output_presets (ChanCount in, ChanCount out)
416 if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) {
417 // collect possible configurations, prefer given in/out
418 _plugins[0]->can_support_io_configuration (in, out);
421 PluginOutputConfiguration ppc (_plugins[0]->possible_output ());
423 if (ppc.size () == 0) {
426 if (!strict_io () && ppc.size () == 1) {
430 if (strict_io () && ppc.size () == 1) {
431 // "stereo" is currently preferred default for instruments
432 if (ppc.find (2) != ppc.end ()) {
437 if (ppc.size () == 1 && ppc.find (0) != ppc.end () && !_plugins[0]->get_info ()->reconfigurable_io ()) {
438 // some midi-sequencer (e.g. QMidiArp) or other midi-out plugin
439 // pretending to be an "Instrument"
443 if (!is_instrument ()) {
450 PluginInsert::create_automatable_parameters ()
452 assert (!_plugins.empty());
454 boost::shared_ptr<Plugin> plugin = _plugins.front();
455 set<Evoral::Parameter> a = _plugins.front()->automatable ();
457 for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
458 if (!plugin->parameter_is_control (i)) {
462 ParameterDescriptor desc;
463 plugin->get_parameter_descriptor(i, desc);
465 if (!plugin->parameter_is_input (i)) {
466 _control_outputs[i] = boost::shared_ptr<ReadOnlyControl> (new ReadOnlyControl (plugin, desc, i));
469 Evoral::Parameter param (PluginAutomation, 0, i);
471 const bool automatable = a.find(param) != a.end();
474 can_automate (param);
476 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
477 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
479 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
482 plugin->set_automation_control (i, c);
486 const Plugin::PropertyDescriptors& pdl (plugin->get_supported_properties ());
487 for (Plugin::PropertyDescriptors::const_iterator p = pdl.begin(); p != pdl.end(); ++p) {
488 Evoral::Parameter param (PluginPropertyAutomation, 0, p->first);
489 const ParameterDescriptor& desc = plugin->get_property_descriptor(param.id());
490 if (desc.datatype != Variant::NOTHING) {
491 boost::shared_ptr<AutomationList> list;
492 if (Variant::type_is_numeric(desc.datatype)) {
493 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
495 boost::shared_ptr<AutomationControl> c (new PluginPropertyControl(this, param, desc, list));
496 if (!Variant::type_is_numeric(desc.datatype)) {
497 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
503 _bypass_port = plugin->designated_bypass_port ();
505 /* special case VST effSetBypass */
506 if (_bypass_port == UINT32_MAX -1) {
507 // emulate VST Bypass
508 Evoral::Parameter param (PluginAutomation, 0, _bypass_port);
509 ParameterDescriptor desc;
510 desc.label = _("Plugin Enable");
515 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
516 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
520 if (_bypass_port != UINT32_MAX) {
521 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
522 if (0 == (ac->flags () & Controllable::NotAutomatable)) {
523 ac->alist()->automation_state_changed.connect_same_thread (*this, boost::bind (&PluginInsert::bypassable_changed, this));
524 ac->Changed.connect_same_thread (*this, boost::bind (&PluginInsert::enable_changed, this));
527 plugin->PresetPortSetValue.connect_same_thread (*this, boost::bind (&PluginInsert::preset_load_set_value, this, _1, _2));
530 /** Called when something outside of this host has modified a plugin
531 * parameter. Responsible for propagating the change to two places:
533 * 1) anything listening to the Control itself
534 * 2) any replicated plugins that make up this PluginInsert.
536 * The PluginInsert is connected to the ParameterChangedExternally signal for
537 * the first (primary) plugin, and here broadcasts that change to any others.
539 * XXX We should probably drop this whole replication idea (Paul, October 2015)
540 * since it isn't used by sensible plugin APIs (AU, LV2).
543 PluginInsert::parameter_changed_externally (uint32_t which, float val)
545 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
547 /* First propagation: alter the underlying value of the control,
548 * without telling the plugin(s) that own/use it to set it.
555 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
558 pc->catch_up_with_external_value (val);
561 /* Second propagation: tell all plugins except the first to
562 update the value of this parameter. For sane plugin APIs,
563 there are no other plugins, so this is a no-op in those
567 Plugins::iterator i = _plugins.begin();
569 /* don't set the first plugin, just all the slaves */
571 if (i != _plugins.end()) {
573 for (; i != _plugins.end(); ++i) {
574 (*i)->set_parameter (which, val);
580 PluginInsert::set_block_size (pframes_t nframes)
583 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
584 if ((*i)->set_block_size (nframes) != 0) {
592 PluginInsert::activate ()
594 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
598 Processor::activate ();
599 /* when setting state e.g ProcessorBox::paste_processor_state ()
600 * the plugin is not yet owned by a route.
601 * but no matter. Route::add_processors() will call activate () again
606 if (_plugin_signal_latency != signal_latency ()) {
607 _plugin_signal_latency = signal_latency ();
613 PluginInsert::deactivate ()
615 Processor::deactivate ();
617 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
620 if (_plugin_signal_latency != signal_latency ()) {
621 _plugin_signal_latency = signal_latency ();
627 PluginInsert::flush ()
629 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
635 PluginInsert::enable (bool yn)
637 if (_bypass_port == UINT32_MAX) {
644 if (!_pending_active) {
647 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
648 const double val = yn ? 1.0 : 0.0;
649 ac->set_value (val, Controllable::NoGroup);
651 #ifdef ALLOW_VST_BYPASS_TO_FAIL // yet unused, see also vst_plugin.cc
652 /* special case VST.. bypass may fail */
653 if (_bypass_port == UINT32_MAX - 1) {
654 /* check if bypass worked */
655 if (ac->get_value () != val) {
656 warning << _("PluginInsert: VST Bypass failed, falling back to host bypass.") << endmsg;
657 // set plugin to enabled (not-byassed)
658 ac->set_value (1.0, Controllable::NoGroup);
659 // ..and use host-provided hard-bypass
674 PluginInsert::enabled () const
676 if (_bypass_port == UINT32_MAX) {
677 return Processor::enabled ();
679 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
680 return (ac->get_value () > 0 && _pending_active);
685 PluginInsert::bypassable () const
687 if (_bypass_port == UINT32_MAX) {
690 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
692 return !ac->automation_playback ();
697 PluginInsert::enable_changed ()
703 PluginInsert::bypassable_changed ()
705 BypassableChanged ();
709 PluginInsert::write_immediate_event (size_t size, const uint8_t* buf)
712 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
713 if (!(*i)->write_immediate_event (size, buf)) {
721 PluginInsert::preset_load_set_value (uint32_t p, float v)
723 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, p));
728 if (ac->automation_state() & Play) {
733 ac->set_value (v, Controllable::NoGroup);
738 PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, samplecnt_t nframes, samplecnt_t offset) const
740 // TODO optimize: store "unconnected" in a fixed set.
741 // it only changes on reconfiguration.
742 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
743 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
745 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
746 mapped = true; // in-place Midi bypass
748 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
749 PinMappings::const_iterator i = out_map.find (pc);
750 if (i == out_map.end ()) {
753 const ChanMapping& outmap (i->second);
754 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
756 uint32_t idx = outmap.get (*t, o, &valid);
757 if (valid && idx == out) {
764 bufs.get (*t, out).silence (nframes, offset);
771 PluginInsert::connect_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes, samplecnt_t offset, bool with_auto)
773 // TODO: atomically copy maps & _no_inplace
774 PinMappings in_map (_in_map);
775 PinMappings out_map (_out_map);
776 ChanMapping thru_map (_thru_map);
777 if (_mapping_changed) { // ToDo use a counters, increment until match.
778 _no_inplace = check_inplace ();
779 _mapping_changed = false;
782 if (_latency_changed) {
783 /* delaylines are configured with the max possible latency (as reported by the plugin)
784 * so this won't allocate memory (unless the plugin lied about its max latency)
785 * It may still 'click' though, since the fixed delaylines are not de-clicked.
786 * Then again plugin-latency changes are not click-free to begin with.
788 * This is also worst case, there is currently no concept of per-stream latency.
790 * e.g. Two identical latent plugins:
791 * 1st plugin: process left (latent), bypass right.
792 * 2nd plugin: bypass left, process right (latent).
793 * -> currently this yields 2 times latency of the plugin,
795 _latency_changed = false;
796 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
799 if (_match.method == Split && !_no_inplace) {
800 // TODO: also use this optimization if one source-buffer
801 // feeds _all_ *connected* inputs.
802 // currently this is *first* buffer to all only --
803 // see PluginInsert::check_inplace
804 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
805 if (_configured_internal.get (*t) == 0) {
809 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
810 assert (valid && first_idx == 0); // check_inplace ensures this
811 /* copy the first stream's buffer contents to the others */
812 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
813 uint32_t idx = in_map[0].get (*t, i, &valid);
816 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
820 /* the copy operation produces a linear monotonic input map */
821 in_map[0] = ChanMapping (natural_input_streams ());
824 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
825 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
831 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
833 boost::shared_ptr<AutomationControl> c
834 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
836 if (c->list() && c->automation_playback()) {
839 const float val = c->list()->rt_safe_eval (start, valid);
842 /* This is the ONLY place where we are
844 * AutomationControl::set_value_unchecked(). We
845 * know that the control is in
846 * automation playback mode, so no
847 * check on writable() is required
848 * (which must be done in AutomationControl::set_value()
851 c->set_value_unchecked(val);
858 /* Calculate if, and how many samples we need to collect for analysis */
859 samplecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
860 _signal_analysis_collected_nframes);
861 if (nframes < collect_signal_nframes) { // we might not get all samples now
862 collect_signal_nframes = nframes;
865 if (collect_signal_nframes > 0) {
867 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
868 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
869 //std::cerr << "filling buffer with " << collect_signal_nframes << " samples at " << _signal_analysis_collected_nframes << std::endl;
871 _signal_analysis_inputs.set_count(input_streams());
873 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
874 _signal_analysis_inputs.get_audio(i).read_from (
876 collect_signal_nframes,
877 _signal_analysis_collected_nframes); // offset is for target buffer
882 if (is_channelstrip ()) {
883 if (_configured_in.n_audio() > 0) {
884 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
885 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
887 _plugins.front()->connect_and_run (bufs, start, end, speed, mb_in_map, mb_out_map, nframes, offset);
889 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
890 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
896 // TODO optimize -- build maps once.
898 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
899 ARDOUR::ChanMapping used_outputs;
901 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
903 /* build used-output map */
904 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
905 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
906 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
908 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
910 used_outputs.set (*t, out_idx, 1); // mark as used
915 /* copy thru data to outputs before processing in-place */
916 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
917 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
919 uint32_t in_idx = thru_map.get (*t, out, &valid);
920 uint32_t m = out + natural_input_streams ().get (*t);
922 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
923 used_outputs.set (*t, out, 1); // mark as used
925 used_outputs.get (*t, out, &valid);
927 /* the plugin is expected to write here, but may not :(
928 * (e.g. drumgizmo w/o kit loaded)
930 inplace_bufs.get (*t, m).silence (nframes);
937 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
939 ARDOUR::ChanMapping i_in_map (natural_input_streams());
940 ARDOUR::ChanMapping i_out_map (out_map[pc]);
941 ARDOUR::ChanCount mapped;
943 /* map inputs sequentially */
944 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
945 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
947 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
948 uint32_t m = mapped.get (*t);
950 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
952 inplace_bufs.get (*t, m).silence (nframes, offset);
954 mapped.set (*t, m + 1);
958 /* outputs are mapped to inplace_bufs after the inputs */
959 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
960 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
963 if ((*i)->connect_and_run (inplace_bufs, start, end, speed, i_in_map, i_out_map, nframes, offset)) {
968 /* all instances have completed, now copy data that was written
969 * and zero unconnected buffers */
970 ARDOUR::ChanMapping nonzero_out (used_outputs);
971 if (has_midi_bypass ()) {
972 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
974 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
975 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
977 used_outputs.get (*t, out, &valid);
979 nonzero_out.get (*t, out, &valid);
981 bufs.get (*t, out).silence (nframes, offset);
984 uint32_t m = out + natural_input_streams ().get (*t);
985 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
990 /* in-place processing */
992 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
993 if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) {
997 // now silence unconnected outputs
998 inplace_silence_unconnected (bufs, _out_map, nframes, offset);
1001 if (collect_signal_nframes > 0) {
1003 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
1004 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
1006 _signal_analysis_outputs.set_count(output_streams());
1008 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
1009 _signal_analysis_outputs.get_audio(i).read_from(
1011 collect_signal_nframes,
1012 _signal_analysis_collected_nframes); // offset is for target buffer
1015 _signal_analysis_collected_nframes += collect_signal_nframes;
1016 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
1018 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
1019 _signal_analysis_collect_nframes_max = 0;
1020 _signal_analysis_collected_nframes = 0;
1022 AnalysisDataGathered(&_signal_analysis_inputs,
1023 &_signal_analysis_outputs);
1027 if (_plugin_signal_latency != signal_latency ()) {
1028 _plugin_signal_latency = signal_latency ();
1034 PluginInsert::bypass (BufferSet& bufs, pframes_t nframes)
1036 /* bypass the plugin(s) not the whole processor.
1037 * -> use mappings just like connect_and_run
1040 // TODO: atomically copy maps & _no_inplace
1041 const ChanMapping in_map (no_sc_input_map ());
1042 const ChanMapping out_map (output_map ());
1043 if (_mapping_changed) {
1044 _no_inplace = check_inplace ();
1045 _mapping_changed = false;
1048 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
1049 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
1052 ChanMapping thru_map (_thru_map);
1054 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
1056 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1057 for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) {
1058 inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0);
1061 ARDOUR::ChanMapping used_outputs;
1063 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1064 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1066 uint32_t in_idx = thru_map.get (*t, out, &valid);
1068 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
1069 used_outputs.set (*t, out, 1); // mark as used
1073 // plugin no-op: assume every plugin has an internal identity map
1074 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1075 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1077 uint32_t src_idx = out_map.get_src (*t, out, &valid);
1081 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
1085 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
1086 used_outputs.set (*t, out, 1); // mark as used
1089 // now silence all unused outputs
1090 if (has_midi_bypass ()) {
1091 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
1093 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1094 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1096 used_outputs.get (*t, out, &valid);
1098 bufs.get (*t, out).silence (nframes, 0);
1103 if (_match.method == Split) {
1104 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1105 if (_configured_internal.get (*t) == 0) {
1108 // copy/feeds _all_ *connected* inputs, copy the first buffer
1110 uint32_t first_idx = in_map.get (*t, 0, &valid);
1111 assert (valid && first_idx == 0); // check_inplace ensures this
1112 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1113 uint32_t idx = in_map.get (*t, i, &valid);
1116 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0);
1122 // apply output map and/or monotonic but not identity i/o mappings
1123 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1124 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1126 uint32_t src_idx = out_map.get_src (*t, out, &valid);
1128 bufs.get (*t, out).silence (nframes, 0);
1131 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
1133 bufs.get (*t, out).silence (nframes, 0);
1136 if (in_idx != src_idx) {
1137 bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0);
1145 PluginInsert::silence (samplecnt_t nframes, samplepos_t start_sample)
1147 automation_run (start_sample, nframes); // evaluate automation only
1150 // XXX delaybuffers need to be offset by nframes
1154 _delaybuffers.flush ();
1156 ChanMapping in_map (natural_input_streams ());
1157 ChanMapping out_map (natural_output_streams ());
1158 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
1160 if (is_channelstrip ()) {
1161 if (_configured_in.n_audio() > 0) {
1162 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0);
1166 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1167 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0);
1172 PluginInsert::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool)
1175 // collect sidechain input for complete cycle (!)
1176 // TODO we need delaylines here for latency compensation
1177 _sidechain->run (bufs, start_sample, end_sample, speed, nframes, true);
1180 if (_pending_active) {
1181 /* run as normal if we are active or moving from inactive to active */
1183 if (_session.transport_rolling() || _session.bounce_processing()) {
1184 automate_and_run (bufs, start_sample, end_sample, speed, nframes);
1186 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1187 connect_and_run (bufs, start_sample, end_sample, speed, nframes, 0, lm.locked());
1191 // XXX should call ::silence() to run plugin(s) for consistent load.
1192 // We'll need to change this anyway when bypass can be automated
1193 bypass (bufs, nframes);
1194 automation_run (start_sample, nframes); // evaluate automation only
1195 _delaybuffers.flush ();
1198 _active = _pending_active;
1200 /* we have no idea whether the plugin generated silence or not, so mark
1201 * all buffers appropriately.
1206 PluginInsert::automate_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes)
1208 Evoral::ControlEvent next_event (0, 0.0f);
1209 samplecnt_t offset = 0;
1211 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1214 connect_and_run (bufs, start, end, speed, nframes, offset, false);
1218 if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1220 /* no events have a time within the relevant range */
1222 connect_and_run (bufs, start, end, speed, nframes, offset, true);
1228 samplecnt_t cnt = min (((samplecnt_t) ceil (next_event.when) - start), (samplecnt_t) nframes);
1230 connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed
1236 if (!find_next_event (start, end, next_event)) {
1241 /* cleanup anything that is left to do */
1244 connect_and_run (bufs, start, start + nframes, speed, nframes, offset, true);
1249 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1251 if (param.type() != PluginAutomation)
1254 if (_plugins.empty()) {
1255 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1257 abort(); /*NOTREACHED*/
1260 return _plugins[0]->default_value (param.id());
1265 PluginInsert::can_reset_all_parameters ()
1268 uint32_t params = 0;
1269 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1271 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1273 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1277 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1283 if (ac->automation_state() & Play) {
1288 return all && (params > 0);
1292 PluginInsert::reset_parameters_to_default ()
1296 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1298 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1300 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1304 const float dflt = _plugins[0]->default_value (cid);
1305 const float curr = _plugins[0]->get_parameter (cid);
1311 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1316 if (ac->automation_state() & Play) {
1321 ac->set_value (dflt, Controllable::NoGroup);
1326 boost::shared_ptr<Plugin>
1327 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1329 boost::shared_ptr<LadspaPlugin> lp;
1330 boost::shared_ptr<LuaProc> lua;
1332 boost::shared_ptr<LV2Plugin> lv2p;
1334 #ifdef WINDOWS_VST_SUPPORT
1335 boost::shared_ptr<WindowsVSTPlugin> vp;
1337 #ifdef LXVST_SUPPORT
1338 boost::shared_ptr<LXVSTPlugin> lxvp;
1340 #ifdef MACVST_SUPPORT
1341 boost::shared_ptr<MacVSTPlugin> mvp;
1343 #ifdef AUDIOUNIT_SUPPORT
1344 boost::shared_ptr<AUPlugin> ap;
1347 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1348 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1349 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1350 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1352 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1353 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1355 #ifdef WINDOWS_VST_SUPPORT
1356 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1357 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1359 #ifdef LXVST_SUPPORT
1360 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1361 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1363 #ifdef MACVST_SUPPORT
1364 } else if ((mvp = boost::dynamic_pointer_cast<MacVSTPlugin> (other)) != 0) {
1365 return boost::shared_ptr<Plugin> (new MacVSTPlugin (*mvp));
1367 #ifdef AUDIOUNIT_SUPPORT
1368 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1369 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1373 fatal << string_compose (_("programming error: %1"),
1374 X_("unknown plugin type in PluginInsert::plugin_factory"))
1376 abort(); /*NOTREACHED*/
1377 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1381 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1382 if (num < _in_map.size()) {
1383 bool changed = _in_map[num] != m;
1385 changed |= sanitize_maps ();
1387 PluginMapChanged (); /* EMIT SIGNAL */
1388 _mapping_changed = true;
1389 _session.set_dirty();
1395 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1396 if (num < _out_map.size()) {
1397 bool changed = _out_map[num] != m;
1399 changed |= sanitize_maps ();
1401 PluginMapChanged (); /* EMIT SIGNAL */
1402 _mapping_changed = true;
1403 _session.set_dirty();
1409 PluginInsert::set_thru_map (ChanMapping m) {
1410 bool changed = _thru_map != m;
1412 changed |= sanitize_maps ();
1414 PluginMapChanged (); /* EMIT SIGNAL */
1415 _mapping_changed = true;
1416 _session.set_dirty();
1421 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1422 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1424 if (_configured) { return false; }
1425 _configured_in = in;
1426 _configured_out = out;
1430 _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1435 PluginInsert::input_map () const
1439 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1440 ChanMapping m (i->second);
1441 const ChanMapping::Mappings& mp ((*i).second.mappings());
1442 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1443 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1444 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1453 PluginInsert::no_sc_input_map () const
1457 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1458 ChanMapping m (i->second);
1459 const ChanMapping::Mappings& mp ((*i).second.mappings());
1460 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1461 uint32_t ins = natural_input_streams().get(tm->first) - _cached_sidechain_pins.get(tm->first);
1462 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1463 if (i->first < ins) {
1464 rv.set (tm->first, i->first + pc * ins, i->second);
1473 PluginInsert::output_map () const
1477 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1478 ChanMapping m (i->second);
1479 const ChanMapping::Mappings& mp ((*i).second.mappings());
1480 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1481 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1482 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1486 if (has_midi_bypass ()) {
1487 rv.set (DataType::MIDI, 0, 0);
1494 PluginInsert::has_midi_bypass () const
1496 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1497 && natural_output_streams ().n_midi () == 0) {
1504 PluginInsert::has_midi_thru () const
1506 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1507 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1515 PluginInsert::is_channelstrip () const {
1516 return _plugins.front()->is_channelstrip();
1521 PluginInsert::check_inplace ()
1523 bool inplace_ok = !_plugins.front()->inplace_broken ();
1525 if (_thru_map.n_total () > 0) {
1526 // TODO once midi-bypass is part of the mapping, ignore it
1530 if (_match.method == Split && inplace_ok) {
1531 assert (get_count() == 1);
1532 assert (_in_map.size () == 1);
1533 if (!_out_map[0].is_monotonic ()) {
1536 if (_configured_internal != _configured_in) {
1537 /* no sidechain -- TODO we could allow this with
1538 * some more logic in PluginInsert::connect_and_run().
1540 * PluginInsert::reset_map() already maps it.
1545 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1546 if (_configured_internal.get (*t) == 0) {
1550 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1551 if (!valid || first_idx != 0) {
1552 // so far only allow to copy the *first* stream's buffer to others
1555 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1556 uint32_t idx = _in_map[0].get (*t, i, &valid);
1557 if (valid && idx != first_idx) {
1566 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1571 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1572 if (!_in_map[pc].is_monotonic ()) {
1575 if (!_out_map[pc].is_monotonic ()) {
1581 /* check if every output is fed by the corresponding input
1583 * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2
1584 * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1)
1586 * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
1588 ChanMapping in_map (input_map ());
1589 const ChanMapping::Mappings out_m (output_map ().mappings ());
1590 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1591 for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1592 /* src-pin: c->first, out-port: c->second */
1594 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1595 if (valid && in_port != c->second) {
1603 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1604 return !inplace_ok; // no-inplace
1608 PluginInsert::sanitize_maps ()
1610 bool changed = false;
1611 /* strip dead wood */
1612 PinMappings new_ins;
1613 PinMappings new_outs;
1614 ChanMapping new_thru;
1616 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1618 ChanMapping new_out;
1619 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1620 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1622 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1623 if (valid && idx < _configured_internal.get (*t)) {
1624 new_in.set (*t, i, idx);
1627 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1629 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1630 if (valid && idx < _configured_out.get (*t)) {
1631 new_out.set (*t, o, idx);
1635 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1638 new_ins[pc] = new_in;
1639 new_outs[pc] = new_out;
1642 /* prevent dup output assignments */
1643 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1644 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1645 bool mapped = false;
1646 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1648 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1649 if (valid && mapped) {
1650 new_outs[pc].unset (*t, idx);
1658 /* remove excess thru */
1659 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1660 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1662 uint32_t idx = _thru_map.get (*t, o, &valid);
1663 if (valid && idx < _configured_internal.get (*t)) {
1664 new_thru.set (*t, o, idx);
1669 /* prevent out + thru, existing plugin outputs override thru */
1670 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1671 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1672 bool mapped = false;
1674 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1675 new_outs[pc].get_src (*t, o, &mapped);
1676 if (mapped) { break; }
1678 if (!mapped) { continue; }
1679 uint32_t idx = new_thru.get (*t, o, &valid);
1681 new_thru.unset (*t, idx);
1686 if (has_midi_bypass ()) {
1687 // TODO: include midi-bypass in the thru set,
1688 // remove dedicated handling.
1689 new_thru.unset (DataType::MIDI, 0);
1692 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1696 _out_map = new_outs;
1697 _thru_map = new_thru;
1703 PluginInsert::reset_map (bool emit)
1705 const PinMappings old_in (_in_map);
1706 const PinMappings old_out (_out_map);
1710 _thru_map = ChanMapping ();
1712 /* build input map */
1713 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1714 uint32_t sc = 0; // side-chain round-robin (all instances)
1716 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1717 const uint32_t nis = natural_input_streams ().get(*t);
1718 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1720 /* SC inputs are last in the plugin-insert.. */
1721 const uint32_t sc_start = _configured_in.get (*t);
1722 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1723 /* ...but may not be at the end of the plugin ports.
1724 * in case the side-chain is not the last port, shift connections back.
1725 * and connect to side-chain
1728 uint32_t ic = 0; // split inputs
1729 const uint32_t cend = _configured_in.get (*t);
1731 for (uint32_t in = 0; in < nis; ++in) {
1732 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1733 if (iod.is_sidechain) {
1734 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1735 if (sc_len > 0) {// side-chain may be hidden
1736 _in_map[pc].set (*t, in, sc_start + sc);
1737 sc = (sc + 1) % sc_len;
1741 if (_match.method == Split) {
1742 if (cend == 0) { continue; }
1743 if (_strict_io && ic + stride * pc >= cend) {
1746 /* connect *no* sidechain sinks in round-robin fashion */
1747 _in_map[pc].set (*t, in, ic + stride * pc);
1748 if (_strict_io && (ic + 1) == cend) {
1751 ic = (ic + 1) % cend;
1753 uint32_t s = in - shift;
1754 if (stride * pc + s < cend) {
1755 _in_map[pc].set (*t, in, s + stride * pc);
1763 /* build output map */
1765 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1766 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1767 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1768 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1773 if (old_in == _in_map && old_out == _out_map) {
1777 PluginMapChanged (); /* EMIT SIGNAL */
1778 _mapping_changed = true;
1779 _session.set_dirty();
1785 PluginInsert::configure_io (ChanCount in, ChanCount out)
1787 Match old_match = _match;
1789 ChanCount old_internal;
1793 old_pins = natural_input_streams();
1794 old_in = _configured_in;
1795 old_out = _configured_out;
1796 old_internal = _configured_internal;
1798 _configured_in = in;
1799 _configured_internal = in;
1800 _configured_out = out;
1803 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1804 * (currently _sidechain->configure_io always succeeds
1805 * since Processor::configure_io() succeeds)
1807 if (!_sidechain->configure_io (in, out)) {
1808 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1811 _configured_internal += _sidechain->input()->n_ports();
1813 // include (static_cast<Route*>owner())->name() ??
1814 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1817 /* get plugin configuration */
1818 _match = private_can_support_io_configuration (in, out);
1820 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1822 DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
1823 DEBUG_STR_APPEND(a, _match);
1824 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1828 /* set the matching method and number of plugins that we will use to meet this configuration */
1829 if (set_count (_match.plugins) == false) {
1830 PluginIoReConfigure (); /* EMIT SIGNAL */
1831 _configured = false;
1835 /* configure plugins */
1836 switch (_match.method) {
1839 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1840 PluginIoReConfigure (); /* EMIT SIGNAL */
1841 _configured = false;
1847 ChanCount din (_configured_internal);
1848 ChanCount dout (din); // hint
1850 if (_custom_sinks.n_total () > 0) {
1851 din = _custom_sinks;
1854 } else if (_preset_out.n_audio () > 0) {
1855 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1856 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1857 dout.set (DataType::AUDIO, 2);
1859 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1861 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1862 bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1864 if (useins.n_audio() == 0) {
1867 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1869 if (_plugins.front()->configure_io (useins, dout) == false) {
1870 PluginIoReConfigure (); /* EMIT SIGNAL */
1871 _configured = false;
1875 _custom_sinks = din;
1880 if (_plugins.front()->configure_io (in, out) == false) {
1881 PluginIoReConfigure (); /* EMIT SIGNAL */
1882 _configured = false;
1888 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",
1890 _configured ? "Y" : "N",
1891 _maps_from_state ? "Y" : "N",
1892 old_in == in ? "==" : "!=",
1893 old_out == out ? "==" : "!=",
1894 old_pins == natural_input_streams () ? "==" : "!=",
1895 old_match.method == _match.method ? "==" : "!=",
1896 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1897 _in_map.size() == get_count () ? "==" : "!=",
1898 _out_map.size() == get_count () ? "==" : "!="
1901 bool mapping_changed = false;
1902 if (old_in == in && old_out == out
1904 && old_pins == natural_input_streams ()
1905 && old_match.method == _match.method
1906 && old_match.custom_cfg == _match.custom_cfg
1907 && _in_map.size() == _out_map.size()
1908 && _in_map.size() == get_count ()
1910 /* If the configuration has not changed, keep the mapping */
1911 mapping_changed = sanitize_maps ();
1912 } else if (_match.custom_cfg && _configured) {
1913 /* don't touch the map in manual mode */
1914 mapping_changed = sanitize_maps ();
1917 if (is_channelstrip ()) {
1918 /* fake channel map - for wire display */
1921 _thru_map = ChanMapping ();
1922 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1923 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1924 /* set "thru" map for in-place forward of audio */
1925 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1926 _thru_map.set (DataType::AUDIO, i, i);
1928 /* and midi (after implicit 1st channel bypass) */
1929 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1930 _thru_map.set (DataType::MIDI, i, i);
1934 if (_maps_from_state && old_in == in && old_out == out) {
1935 mapping_changed = true;
1938 /* generate a new mapping */
1939 mapping_changed = reset_map (false);
1941 _maps_from_state = false;
1944 if (mapping_changed) {
1945 PluginMapChanged (); /* EMIT SIGNAL */
1948 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1951 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1952 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1954 DEBUG_STR_APPEND(a, "----><----\n");
1956 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1957 DEBUG_STR_APPEND(a, " * Inputs:\n");
1958 DEBUG_STR_APPEND(a, _in_map[pc]);
1959 DEBUG_STR_APPEND(a, " * Outputs:\n");
1960 DEBUG_STR_APPEND(a, _out_map[pc]);
1962 DEBUG_STR_APPEND(a, " * Thru:\n");
1963 DEBUG_STR_APPEND(a, _thru_map);
1964 DEBUG_STR_APPEND(a, "-------->>--------\n");
1965 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1970 _no_inplace = check_inplace ();
1971 _mapping_changed = false;
1973 /* only the "noinplace_buffers" thread buffers need to be this large,
1974 * this can be optimized. other buffers are fine with
1975 * ChanCount::max (natural_input_streams (), natural_output_streams())
1976 * and route.cc's max (configured_in, configured_out)
1978 * no-inplace copies "thru" outputs (to emulate in-place) for
1979 * all outputs (to prevent overwrite) into a temporary space
1980 * which also holds input buffers (in case the plugin does process
1981 * in-place and overwrites those).
1983 * this buffers need to be at least as
1984 * natural_input_streams () + possible outputs.
1986 * sidechain inputs add a constraint on the input:
1987 * configured input + sidechain (=_configured_internal)
1989 * NB. this also satisfies
1990 * max (natural_input_streams(), natural_output_streams())
1991 * which is needed for silence runs
1993 _required_buffers = ChanCount::max (_configured_internal,
1994 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1996 if (old_in != in || old_out != out || old_internal != _configured_internal
1997 || old_pins != natural_input_streams ()
1998 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
2000 PluginIoReConfigure (); /* EMIT SIGNAL */
2003 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
2004 _latency_changed = true;
2006 // we don't know the analysis window size, so we must work with the
2007 // current buffer size here. each request for data fills in these
2008 // buffers and the analyser makes sure it gets enough data for the
2010 session().ensure_buffer_set (_signal_analysis_inputs, in);
2011 _signal_analysis_inputs.set_count (in);
2013 session().ensure_buffer_set (_signal_analysis_outputs, out);
2014 _signal_analysis_outputs.set_count (out);
2016 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
2019 return Processor::configure_io (in, out);
2022 /** Decide whether this PluginInsert can support a given IO configuration.
2023 * To do this, we run through a set of possible solutions in rough order of
2026 * @param in Required input channel count.
2027 * @param out Filled in with the output channel count if we return true.
2028 * @return true if the given IO configuration can be supported.
2031 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
2034 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
2036 return private_can_support_io_configuration (in, out).method != Impossible;
2040 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
2042 if (!_custom_cfg && _preset_out.n_audio () > 0) {
2043 // preseed hint (for variable i/o)
2044 out.set (DataType::AUDIO, _preset_out.n_audio ());
2047 Match rv = internal_can_support_io_configuration (in, out);
2049 if (!_custom_cfg && _preset_out.n_audio () > 0) {
2050 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
2051 out.set (DataType::AUDIO, _preset_out.n_audio ());
2056 /** A private version of can_support_io_configuration which returns the method
2057 * by which the configuration can be matched, rather than just whether or not
2061 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
2063 if (_plugins.empty()) {
2068 if (is_channelstrip ()) {
2070 return Match (ExactMatch, 1);
2074 /* if a user specified a custom cfg, so be it. */
2076 PluginInfoPtr info = _plugins.front()->get_info();
2078 if (info->reconfigurable_io()) {
2079 return Match (Delegate, 1, _strict_io, true);
2081 return Match (ExactMatch, get_count(), _strict_io, true);
2085 /* try automatic configuration */
2086 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
2088 PluginInfoPtr info = _plugins.front()->get_info();
2089 ChanCount inputs = info->n_inputs;
2090 ChanCount outputs = info->n_outputs;
2092 /* handle case strict-i/o */
2093 if (_strict_io && m.method != Impossible) {
2096 /* special case MIDI instruments */
2097 if (is_instrument ()) {
2098 // output = midi-bypass + at most master-out channels.
2099 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
2100 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
2101 out = ChanCount::min (out, max_out);
2102 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
2108 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
2109 /* replicate processor to match output count (generators and such)
2110 * at least enough to feed every output port. */
2111 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
2112 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2113 uint32_t nout = outputs.get (*t);
2114 if (nout == 0 || inx.get(*t) == 0) { continue; }
2115 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
2118 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
2119 return Match (Replicate, f, _strict_io);
2130 if (m.method != Impossible) {
2134 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2136 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
2138 if (info->reconfigurable_io()) {
2141 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2142 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2143 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
2145 // houston, we have a problem.
2146 return Match (Impossible, 0);
2149 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2150 return Match (Delegate, 1, _strict_io);
2153 ChanCount midi_bypass;
2154 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2155 midi_bypass.set (DataType::MIDI, 1);
2158 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
2160 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2161 uint32_t nin = ns_inputs.get (*t);
2162 uint32_t nout = outputs.get (*t);
2163 if (nin == 0 || inx.get(*t) == 0) { continue; }
2164 // prefer floor() so the count won't overly increase IFF (nin < nout)
2165 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
2167 if (f > 0 && outputs * f >= _configured_out) {
2168 out = outputs * f + midi_bypass;
2169 return Match (Replicate, f, _strict_io);
2172 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
2174 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2175 uint32_t nin = ns_inputs.get (*t);
2176 if (nin == 0 || inx.get(*t) == 0) { continue; }
2177 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2180 out = outputs * f + midi_bypass;
2181 return Match (Replicate, f, _strict_io);
2184 // add at least as many plugins needed to connect all inputs
2186 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2187 uint32_t nin = inputs.get (*t);
2188 if (nin == 0 || inx.get(*t) == 0) { continue; }
2189 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2191 out = outputs * f + midi_bypass;
2192 return Match (Replicate, f, _strict_io);
2195 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
2197 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
2199 if (_plugins.empty()) {
2203 PluginInfoPtr info = _plugins.front()->get_info();
2204 ChanCount in; in += inx;
2205 ChanCount midi_bypass;
2207 if (info->reconfigurable_io()) {
2208 /* Plugin has flexible I/O, so delegate to it
2209 * pre-seed outputs, plugin tries closest match
2212 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2213 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2214 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
2216 return Match (Impossible, 0);
2219 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2220 return Match (Delegate, 1);
2223 ChanCount inputs = info->n_inputs;
2224 ChanCount outputs = info->n_outputs;
2225 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2227 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2228 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
2229 midi_bypass.set (DataType::MIDI, 1);
2231 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
2232 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
2233 in.set(DataType::MIDI, 0);
2236 // add internally provided sidechain ports
2237 ChanCount insc = in + sidechain_input_ports ();
2239 bool no_inputs = true;
2240 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2241 if (inputs.get (*t) != 0) {
2248 /* no inputs so we can take any input configuration since we throw it away */
2249 out = outputs + midi_bypass;
2250 return Match (NoInputs, 1);
2253 /* Plugin inputs match requested inputs + side-chain-ports exactly */
2254 if (inputs == insc) {
2255 out = outputs + midi_bypass;
2256 return Match (ExactMatch, 1);
2259 /* Plugin inputs matches without side-chain-pins */
2260 if (ns_inputs == in) {
2261 out = outputs + midi_bypass;
2262 return Match (ExactMatch, 1);
2265 /* We may be able to run more than one copy of the plugin within this insert
2266 to cope with the insert having more inputs than the plugin.
2267 We allow replication only for plugins with either zero or 1 inputs and outputs
2268 for every valid data type.
2272 bool can_replicate = true;
2273 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2275 // ignore side-chains
2276 uint32_t nin = ns_inputs.get (*t);
2278 // No inputs of this type
2279 if (nin == 0 && in.get(*t) == 0) {
2283 if (nin != 1 || outputs.get (*t) != 1) {
2284 can_replicate = false;
2288 // Potential factor not set yet
2290 f = in.get(*t) / nin;
2293 // Factor for this type does not match another type, can not replicate
2294 if (f != (in.get(*t) / nin)) {
2295 can_replicate = false;
2300 if (can_replicate && f > 0) {
2301 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2302 out.set (*t, outputs.get(*t) * f);
2305 return Match (Replicate, f);
2308 /* If the processor has exactly one input of a given type, and
2309 the plugin has more, we can feed the single processor input
2310 to some or all of the plugin inputs. This is rather
2311 special-case-y, but the 1-to-many case is by far the
2312 simplest. How do I split thy 2 processor inputs to 3
2313 plugin inputs? Let me count the ways ...
2316 bool can_split = true;
2317 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2319 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2320 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2322 if (!can_split_type && !nothing_to_do_for_type) {
2328 out = outputs + midi_bypass;
2329 return Match (Split, 1);
2332 /* If the plugin has more inputs than we want, we can `hide' some of them
2333 by feeding them silence.
2336 bool could_hide = false;
2337 bool cannot_hide = false;
2338 ChanCount hide_channels;
2340 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2341 if (inputs.get(*t) > in.get(*t)) {
2342 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2343 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2345 } else if (inputs.get(*t) < in.get(*t)) {
2346 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2351 if (could_hide && !cannot_hide) {
2352 out = outputs + midi_bypass;
2353 return Match (Hide, 1, false, false, hide_channels);
2356 return Match (Impossible, 0);
2361 PluginInsert::state ()
2363 XMLNode& node = Processor::state ();
2365 node.set_property("type", _plugins[0]->state_node_name());
2366 node.set_property("unique-id", _plugins[0]->unique_id());
2367 node.set_property("count", (uint32_t)_plugins.size());
2369 /* remember actual i/o configuration (for later placeholder
2370 * in case the plugin goes missing) */
2371 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2372 node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2373 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2374 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2376 /* save custom i/o config */
2377 node.set_property("custom", _custom_cfg);
2378 for (uint32_t pc = 0; pc < get_count(); ++pc) {
2380 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2381 node.add_child_nocopy (* _in_map[pc].state (tmp));
2382 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2383 node.add_child_nocopy (* _out_map[pc].state (tmp));
2385 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2388 node.add_child_nocopy (_sidechain->get_state ());
2391 _plugins[0]->set_insert_id(this->id());
2392 node.add_child_nocopy (_plugins[0]->get_state());
2394 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2395 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2397 node.add_child_nocopy (ac->get_state());
2405 PluginInsert::set_control_ids (const XMLNode& node, int version)
2407 const XMLNodeList& nlist = node.children();
2408 XMLNodeConstIterator iter;
2409 set<Evoral::Parameter>::const_iterator p;
2411 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2412 if ((*iter)->name() == Controllable::xml_node_name) {
2414 uint32_t p = (uint32_t)-1;
2417 if ((*iter)->get_property (X_("symbol"), str)) {
2418 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2420 p = lv2plugin->port_index(str.c_str());
2424 if (p == (uint32_t)-1) {
2425 (*iter)->get_property (X_("parameter"), p);
2428 if (p != (uint32_t)-1) {
2430 /* this may create the new controllable */
2432 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2434 #ifndef NO_PLUGIN_STATE
2438 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2440 ac->set_state (**iter, version);
2449 PluginInsert::set_state(const XMLNode& node, int version)
2451 XMLNodeList nlist = node.children();
2452 XMLNodeIterator niter;
2453 XMLPropertyList plist;
2454 ARDOUR::PluginType type;
2457 if (!node.get_property ("type", str)) {
2458 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2462 if (str == X_("ladspa") || str == X_("Ladspa")) { /* handle old school sessions */
2463 type = ARDOUR::LADSPA;
2464 } else if (str == X_("lv2")) {
2466 } else if (str == X_("windows-vst")) {
2467 type = ARDOUR::Windows_VST;
2468 } else if (str == X_("lxvst")) {
2469 type = ARDOUR::LXVST;
2470 } else if (str == X_("mac-vst")) {
2471 type = ARDOUR::MacVST;
2472 } else if (str == X_("audiounit")) {
2473 type = ARDOUR::AudioUnit;
2474 } else if (str == X_("luaproc")) {
2477 error << string_compose (_("unknown plugin type %1 in plugin insert state"), str) << endmsg;
2481 XMLProperty const * prop = node.property ("unique-id");
2484 #ifdef WINDOWS_VST_SUPPORT
2485 /* older sessions contain VST plugins with only an "id" field. */
2486 if (type == ARDOUR::Windows_VST) {
2487 prop = node.property ("id");
2491 #ifdef LXVST_SUPPORT
2492 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2493 if (type == ARDOUR::LXVST) {
2494 prop = node.property ("id");
2501 error << _("Plugin has no unique ID field") << endmsg;
2506 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2507 bool any_vst = false;
2509 /* treat VST plugins equivalent if they have the same uniqueID
2510 * allow to move sessions windows <> linux */
2511 #ifdef LXVST_SUPPORT
2512 if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::MacVST)) {
2513 type = ARDOUR::LXVST;
2514 plugin = find_plugin (_session, prop->value(), type);
2515 if (plugin) { any_vst = true; }
2519 #ifdef WINDOWS_VST_SUPPORT
2520 if (plugin == 0 && (type == ARDOUR::LXVST || type == ARDOUR::MacVST)) {
2521 type = ARDOUR::Windows_VST;
2522 plugin = find_plugin (_session, prop->value(), type);
2523 if (plugin) { any_vst = true; }
2527 #ifdef MACVST_SUPPORT
2528 if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::LXVST)) {
2529 type = ARDOUR::MacVST;
2530 plugin = find_plugin (_session, prop->value(), type);
2531 if (plugin) { any_vst = true; }
2535 if (plugin == 0 && type == ARDOUR::Lua) {
2536 /* unique ID (sha1 of script) was not found,
2537 * load the plugin from the serialized version in the
2538 * session-file instead.
2540 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2541 XMLNode *ls = node.child (lp->state_node_name().c_str());
2543 lp->set_script_from_state (*ls);
2549 error << string_compose(
2550 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2551 "Perhaps it was removed or moved since it was last used."),
2557 // The name of the PluginInsert comes from the plugin, nothing else
2558 _name = plugin->get_info()->name;
2562 // Processor::set_state() will set this, but too late
2563 // for it to be available when setting up plugin
2564 // state. We can't call Processor::set_state() until
2565 // the plugins themselves are created and added.
2569 if (_plugins.empty()) {
2570 /* if we are adding the first plugin, we will need to set
2571 up automatable controls.
2573 add_plugin (plugin);
2574 create_automatable_parameters ();
2575 set_control_ids (node, version);
2578 node.get_property ("count", count);
2580 if (_plugins.size() != count) {
2581 for (uint32_t n = 1; n < count; ++n) {
2582 add_plugin (plugin_factory (plugin));
2586 Processor::set_state (node, version);
2588 PBD::ID new_id = this->id();
2589 PBD::ID old_id = this->id();
2591 node.get_property ("id", old_id);
2593 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2595 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2596 and set all plugins to the same state.
2599 if ( ((*niter)->name() == plugin->state_node_name())
2600 || (any_vst && ((*niter)->name() == "lxvst" || (*niter)->name() == "windows-vst" || (*niter)->name() == "mac-vst"))
2603 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2604 /* Plugin state can include external files which are named after the ID.
2606 * If regenerate_xml_or_string_ids() is set, the ID will already have
2607 * been changed, so we need to use the old ID from the XML to load the
2608 * state and then update the ID.
2610 * When copying a plugin-state, route_ui takes care of of updating the ID,
2611 * but we need to call set_insert_id() to clear the cached plugin-state
2612 * and force a change.
2614 if (!regenerate_xml_or_string_ids ()) {
2615 (*i)->set_insert_id (new_id);
2617 (*i)->set_insert_id (old_id);
2620 (*i)->set_state (**niter, version);
2622 if (regenerate_xml_or_string_ids ()) {
2623 (*i)->set_insert_id (new_id);
2627 /* when copying plugin state, notify UI */
2628 for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li) {
2629 boost::shared_ptr<PBD::Controllable> c = boost::dynamic_pointer_cast<PBD::Controllable> (li->second);
2631 c->Changed (false, Controllable::NoGroup); /* EMIT SIGNAL */
2639 if (version < 3000) {
2641 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2642 this is all handled by Automatable
2645 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2646 if ((*niter)->name() == "Redirect") {
2647 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2648 Processor::set_state (**niter, version);
2653 set_parameter_state_2X (node, version);
2656 node.get_property (X_("custom"), _custom_cfg);
2658 uint32_t in_maps = 0;
2659 uint32_t out_maps = 0;
2660 XMLNodeList kids = node.children ();
2661 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2662 if ((*i)->name() == X_("ConfiguredInput")) {
2663 _configured_in = ChanCount(**i);
2665 if ((*i)->name() == X_("CustomSinks")) {
2666 _custom_sinks = ChanCount(**i);
2668 if ((*i)->name() == X_("ConfiguredOutput")) {
2669 _custom_out = ChanCount(**i);
2670 _configured_out = ChanCount(**i);
2672 if ((*i)->name() == X_("PresetOutput")) {
2673 _preset_out = ChanCount(**i);
2675 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2676 long pc = atol (&((*i)->name().c_str()[9]));
2677 if (pc >= 0 && pc <= (long) get_count()) {
2678 _in_map[pc] = ChanMapping (**i);
2682 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2683 long pc = atol (&((*i)->name().c_str()[10]));
2684 if (pc >= 0 && pc <= (long) get_count()) {
2685 _out_map[pc] = ChanMapping (**i);
2689 if ((*i)->name () == "ThruMap") {
2690 _thru_map = ChanMapping (**i);
2693 // sidechain is a Processor (IO)
2694 if ((*i)->name () == Processor::state_node_name) {
2698 if (!regenerate_xml_or_string_ids ()) {
2699 _sidechain->set_state (**i, version);
2704 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2705 _maps_from_state = true;
2708 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2712 (*i)->deactivate ();
2716 PluginConfigChanged (); /* EMIT SIGNAL */
2721 PluginInsert::update_id (PBD::ID id)
2724 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2725 (*i)->set_insert_id (id);
2730 PluginInsert::set_owner (SessionObject* o)
2732 Processor::set_owner (o);
2733 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2734 (*i)->set_owner (o);
2739 PluginInsert::set_state_dir (const std::string& d)
2741 // state() only saves the state of the first plugin
2742 _plugins[0]->set_state_dir (d);
2746 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2748 XMLNodeList nlist = node.children();
2749 XMLNodeIterator niter;
2751 /* look for port automation node */
2753 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2755 if ((*niter)->name() != port_automation_node_name) {
2760 XMLNodeConstIterator iter;
2764 cnodes = (*niter)->children ("port");
2766 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2770 if (!child->get_property("number", port_id)) {
2771 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2775 if (port_id >= _plugins[0]->parameter_count()) {
2776 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2780 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2781 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2783 if (c && c->alist()) {
2784 if (!child->children().empty()) {
2785 c->alist()->set_state (*child->children().front(), version);
2788 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2798 boost::shared_ptr<ReadOnlyControl>
2799 PluginInsert::control_output (uint32_t num) const
2801 CtrlOutMap::const_iterator i = _control_outputs.find (num);
2802 if (i == _control_outputs.end ()) {
2803 return boost::shared_ptr<ReadOnlyControl> ();
2810 PluginInsert::describe_parameter (Evoral::Parameter param)
2812 if (param.type() == PluginAutomation) {
2813 return _plugins[0]->describe_parameter (param);
2814 } else if (param.type() == PluginPropertyAutomation) {
2815 boost::shared_ptr<AutomationControl> c(automation_control(param));
2816 if (c && !c->desc().label.empty()) {
2817 return c->desc().label;
2820 return Automatable::describe_parameter(param);
2824 PluginInsert::signal_latency() const
2826 if (!_pending_active) {
2829 if (_user_latency) {
2830 return _user_latency;
2833 return _plugins[0]->signal_latency ();
2837 PluginInsert::type ()
2839 return plugin()->get_info()->type;
2842 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2843 const Evoral::Parameter& param,
2844 const ParameterDescriptor& desc,
2845 boost::shared_ptr<AutomationList> list)
2846 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2851 list->set_interpolation(Evoral::ControlList::Discrete);
2856 /** @param val `user' value */
2859 PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2861 /* FIXME: probably should be taking out some lock here.. */
2863 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2864 (*i)->set_parameter (_list->parameter().id(), user_val);
2867 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2869 iasp->set_parameter (_list->parameter().id(), user_val);
2872 AutomationControl::actually_set_value (user_val, group_override);
2876 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2878 AutomationControl::actually_set_value (user_val, Controllable::NoGroup);
2882 PluginInsert::PluginControl::get_state ()
2884 XMLNode& node (AutomationControl::get_state());
2885 node.set_property (X_("parameter"), parameter().id());
2887 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2889 node.set_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2896 /** @return `user' val */
2898 PluginInsert::PluginControl::get_value () const
2900 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2906 return plugin->get_parameter (_list->parameter().id());
2909 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2910 const Evoral::Parameter& param,
2911 const ParameterDescriptor& desc,
2912 boost::shared_ptr<AutomationList> list)
2913 : AutomationControl (p->session(), param, desc, list)
2919 PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd)
2921 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2922 This is lossy, but better than nothing until Ardour's automation system
2923 can handle various datatypes all the way down. */
2924 const Variant value(_desc.datatype, user_val);
2925 if (value.type() == Variant::NOTHING) {
2926 error << "set_value(double) called for non-numeric property" << endmsg;
2930 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2931 (*i)->set_property(_list->parameter().id(), value);
2936 AutomationControl::actually_set_value (user_val, gcd);
2940 PluginInsert::PluginPropertyControl::get_state ()
2942 XMLNode& node (AutomationControl::get_state());
2943 node.set_property (X_("property"), parameter().id());
2944 node.remove_property (X_("value"));
2950 PluginInsert::PluginPropertyControl::get_value () const
2952 return _value.to_double();
2955 boost::shared_ptr<Plugin>
2956 PluginInsert::get_impulse_analysis_plugin()
2958 boost::shared_ptr<Plugin> ret;
2959 if (_impulseAnalysisPlugin.expired()) {
2960 // LV2 in particular uses various _session params
2961 // during init() -- most notably block_size..
2963 ret = plugin_factory(_plugins[0]);
2964 ChanCount out (internal_output_streams ());
2965 if (ret->get_info ()->reconfigurable_io ()) {
2966 // populate get_info ()->n_inputs and ->n_outputs
2968 ret->can_support_io_configuration (internal_input_streams (), out, &useins);
2969 assert (out == internal_output_streams ());
2971 ret->configure_io (internal_input_streams (), out);
2972 ret->set_owner (_owner);
2973 _impulseAnalysisPlugin = ret;
2975 ret = _impulseAnalysisPlugin.lock();
2982 PluginInsert::collect_signal_for_analysis (samplecnt_t nframes)
2984 // called from outside the audio thread, so this should be safe
2985 // only do audio as analysis is (currently) only for audio plugins
2986 _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes);
2987 _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
2989 _signal_analysis_collected_nframes = 0;
2990 _signal_analysis_collect_nframes_max = nframes;
2993 /** Add a plugin to our list */
2995 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2997 plugin->set_insert_id (this->id());
2998 plugin->set_owner (_owner);
3000 if (_plugins.empty()) {
3001 /* first (and probably only) plugin instance - connect to relevant signals */
3003 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
3004 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
3005 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
3006 _custom_sinks = plugin->get_info()->n_inputs;
3007 // cache sidechain port count
3008 _cached_sidechain_pins.reset ();
3009 const ChanCount& nis (plugin->get_info()->n_inputs);
3010 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3011 for (uint32_t in = 0; in < nis.get (*t); ++in) {
3012 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
3013 if (iod.is_sidechain) {
3014 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
3019 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT)
3020 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
3022 vst->set_insert (this, _plugins.size ());
3026 _plugins.push_back (plugin);
3030 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
3033 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3034 if (! (*i)->load_preset (pr)) {
3042 PluginInsert::realtime_handle_transport_stopped ()
3044 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3045 (*i)->realtime_handle_transport_stopped ();
3050 PluginInsert::realtime_locate ()
3052 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3053 (*i)->realtime_locate ();
3058 PluginInsert::monitoring_changed ()
3060 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3061 (*i)->monitoring_changed ();
3066 PluginInsert::latency_changed ()
3068 // this is called in RT context, LatencyChanged is emitted after run()
3069 _latency_changed = true;
3070 // XXX This also needs a proper API not an owner() hack.
3072 static_cast<Route*>(owner ())->processor_latency_changed (); /* EMIT SIGNAL */
3076 PluginInsert::start_touch (uint32_t param_id)
3078 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
3080 // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0
3081 ac->start_touch (session().audible_sample());
3086 PluginInsert::end_touch (uint32_t param_id)
3088 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
3090 // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0
3091 ac->stop_touch (session().audible_sample());
3095 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
3098 case PluginInsert::Impossible: o << "Impossible"; break;
3099 case PluginInsert::Delegate: o << "Delegate"; break;
3100 case PluginInsert::NoInputs: o << "NoInputs"; break;
3101 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
3102 case PluginInsert::Replicate: o << "Replicate"; break;
3103 case PluginInsert::Split: o << "Split"; break;
3104 case PluginInsert::Hide: o << "Hide"; break;
3106 o << " cnt: " << m.plugins
3107 << (m.strict_io ? " strict-io" : "")
3108 << (m.custom_cfg ? " custom-cfg" : "");
3109 if (m.method == PluginInsert::Hide) {
3110 o << " hide: " << m.hide;