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::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
242 if (which.type() != PluginAutomation)
245 boost::shared_ptr<AutomationControl> c
246 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
249 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_sample()));
254 PluginInsert::output_streams() const
256 assert (_configured);
257 return _configured_out;
261 PluginInsert::input_streams() const
263 assert (_configured);
264 return _configured_in;
268 PluginInsert::internal_streams() const
270 assert (_configured);
271 return _configured_internal;
275 PluginInsert::internal_output_streams() const
277 assert (!_plugins.empty());
279 PluginInfoPtr info = _plugins.front()->get_info();
281 if (info->reconfigurable_io()) {
282 ChanCount out = _plugins.front()->output_streams ();
283 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
286 ChanCount out = info->n_outputs;
287 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
288 out.set_audio (out.n_audio() * _plugins.size());
289 out.set_midi (out.n_midi() * _plugins.size());
295 PluginInsert::internal_input_streams() const
297 assert (!_plugins.empty());
301 PluginInfoPtr info = _plugins.front()->get_info();
303 if (info->reconfigurable_io()) {
304 in = _plugins.front()->input_streams();
309 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
311 if (_match.method == Split) {
313 /* we are splitting 1 processor input to multiple plugin inputs,
314 so we have a maximum of 1 stream of each type.
316 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
317 if (in.get (*t) > 1) {
323 } else if (_match.method == Hide) {
325 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
326 in.set (*t, in.get (*t) - _match.hide.get (*t));
332 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
333 in.set (*t, in.get (*t) * _plugins.size ());
341 PluginInsert::natural_output_streams() const
344 if (is_channelstrip ()) {
345 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
348 return _plugins[0]->get_info()->n_outputs;
352 PluginInsert::natural_input_streams() const
355 if (is_channelstrip ()) {
356 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
359 return _plugins[0]->get_info()->n_inputs;
363 PluginInsert::sidechain_input_pins() const
365 return _cached_sidechain_pins;
369 PluginInsert::has_no_inputs() const
371 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
375 PluginInsert::has_no_audio_inputs() const
377 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
381 PluginInsert::plugin_latency () const {
382 return _plugins.front()->signal_latency ();
386 PluginInsert::is_instrument() const
388 PluginInfoPtr pip = _plugins[0]->get_info();
389 return (pip->is_instrument ());
393 PluginInsert::has_output_presets (ChanCount in, ChanCount out)
395 if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) {
396 // collect possible configurations, prefer given in/out
397 _plugins[0]->can_support_io_configuration (in, out);
400 PluginOutputConfiguration ppc (_plugins[0]->possible_output ());
402 if (ppc.size () == 0) {
405 if (!strict_io () && ppc.size () == 1) {
409 if (strict_io () && ppc.size () == 1) {
410 // "stereo" is currently preferred default for instruments
411 if (ppc.find (2) != ppc.end ()) {
416 if (ppc.size () == 1 && ppc.find (0) != ppc.end () && !_plugins[0]->get_info ()->reconfigurable_io ()) {
417 // some midi-sequencer (e.g. QMidiArp) or other midi-out plugin
418 // pretending to be an "Instrument"
422 if (!is_instrument ()) {
429 PluginInsert::create_automatable_parameters ()
431 assert (!_plugins.empty());
433 boost::shared_ptr<Plugin> plugin = _plugins.front();
434 set<Evoral::Parameter> a = _plugins.front()->automatable ();
436 for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
437 if (!plugin->parameter_is_control (i)) {
441 ParameterDescriptor desc;
442 plugin->get_parameter_descriptor(i, desc);
444 if (!plugin->parameter_is_input (i)) {
445 _control_outputs[i] = boost::shared_ptr<ReadOnlyControl> (new ReadOnlyControl (plugin, desc, i));
448 Evoral::Parameter param (PluginAutomation, 0, i);
450 const bool automatable = a.find(param) != a.end();
453 can_automate (param);
455 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
456 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
458 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
461 plugin->set_automation_control (i, c);
465 const Plugin::PropertyDescriptors& pdl (plugin->get_supported_properties ());
466 for (Plugin::PropertyDescriptors::const_iterator p = pdl.begin(); p != pdl.end(); ++p) {
467 Evoral::Parameter param (PluginPropertyAutomation, 0, p->first);
468 const ParameterDescriptor& desc = plugin->get_property_descriptor(param.id());
469 if (desc.datatype != Variant::NOTHING) {
470 boost::shared_ptr<AutomationList> list;
471 if (Variant::type_is_numeric(desc.datatype)) {
472 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
474 boost::shared_ptr<AutomationControl> c (new PluginPropertyControl(this, param, desc, list));
475 if (!Variant::type_is_numeric(desc.datatype)) {
476 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
482 _bypass_port = plugin->designated_bypass_port ();
484 /* special case VST effSetBypass */
485 if (_bypass_port == UINT32_MAX -1) {
486 // emulate VST Bypass
487 Evoral::Parameter param (PluginAutomation, 0, _bypass_port);
488 ParameterDescriptor desc;
489 desc.label = _("Plugin Enable");
494 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
495 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
499 if (_bypass_port != UINT32_MAX) {
500 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
501 if (0 == (ac->flags () & Controllable::NotAutomatable)) {
502 ac->alist()->automation_state_changed.connect_same_thread (*this, boost::bind (&PluginInsert::bypassable_changed, this));
503 ac->Changed.connect_same_thread (*this, boost::bind (&PluginInsert::enable_changed, this));
506 plugin->PresetPortSetValue.connect_same_thread (*this, boost::bind (&PluginInsert::preset_load_set_value, this, _1, _2));
509 /** Called when something outside of this host has modified a plugin
510 * parameter. Responsible for propagating the change to two places:
512 * 1) anything listening to the Control itself
513 * 2) any replicated plugins that make up this PluginInsert.
515 * The PluginInsert is connected to the ParameterChangedExternally signal for
516 * the first (primary) plugin, and here broadcasts that change to any others.
518 * XXX We should probably drop this whole replication idea (Paul, October 2015)
519 * since it isn't used by sensible plugin APIs (AU, LV2).
522 PluginInsert::parameter_changed_externally (uint32_t which, float val)
524 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
526 /* First propagation: alter the underlying value of the control,
527 * without telling the plugin(s) that own/use it to set it.
534 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
537 pc->catch_up_with_external_value (val);
540 /* Second propagation: tell all plugins except the first to
541 update the value of this parameter. For sane plugin APIs,
542 there are no other plugins, so this is a no-op in those
546 Plugins::iterator i = _plugins.begin();
548 /* don't set the first plugin, just all the slaves */
550 if (i != _plugins.end()) {
552 for (; i != _plugins.end(); ++i) {
553 (*i)->set_parameter (which, val);
559 PluginInsert::set_block_size (pframes_t nframes)
562 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
563 if ((*i)->set_block_size (nframes) != 0) {
571 PluginInsert::automation_run (samplepos_t start, pframes_t nframes)
573 // XXX does not work when rolling backwards
574 if (_loop_location && nframes > 0) {
575 const samplepos_t loop_start = _loop_location->start ();
576 const samplepos_t loop_end = _loop_location->end ();
577 const samplecnt_t looplen = loop_end - loop_start;
579 samplecnt_t remain = nframes;
580 samplepos_t start_pos = start;
583 if (start_pos >= loop_end) {
584 sampleoffset_t start_off = (start_pos - loop_start) % looplen;
585 start_pos = loop_start + start_off;
587 samplecnt_t move = std::min ((samplecnt_t)nframes, loop_end - start_pos);
589 Automatable::automation_run (start_pos, move);
595 Automatable::automation_run (start, nframes);
599 PluginInsert::find_next_event (double now, double end, Evoral::ControlEvent& next_event, bool only_active) const
601 bool rv = Automatable::find_next_event (now, end, next_event, only_active);
603 if (_loop_location && now < end) {
605 end = ceil (next_event.when);
607 const samplepos_t loop_end = _loop_location->end ();
608 assert (now < loop_end); // due to map_loop_range ()
609 if (end > loop_end) {
610 next_event.when = loop_end;
618 PluginInsert::activate ()
620 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
624 Processor::activate ();
625 /* when setting state e.g ProcessorBox::paste_processor_state ()
626 * the plugin is not yet owned by a route.
627 * but no matter. Route::add_processors() will call activate () again
632 if (_plugin_signal_latency != signal_latency ()) {
633 _plugin_signal_latency = signal_latency ();
639 PluginInsert::deactivate ()
641 Processor::deactivate ();
643 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
646 if (_plugin_signal_latency != signal_latency ()) {
647 _plugin_signal_latency = signal_latency ();
653 PluginInsert::flush ()
655 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
661 PluginInsert::enable (bool yn)
663 if (_bypass_port == UINT32_MAX) {
670 if (!_pending_active) {
673 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
674 const double val = yn ? 1.0 : 0.0;
675 ac->set_value (val, Controllable::NoGroup);
677 #ifdef ALLOW_VST_BYPASS_TO_FAIL // yet unused, see also vst_plugin.cc
678 /* special case VST.. bypass may fail */
679 if (_bypass_port == UINT32_MAX - 1) {
680 /* check if bypass worked */
681 if (ac->get_value () != val) {
682 warning << _("PluginInsert: VST Bypass failed, falling back to host bypass.") << endmsg;
683 // set plugin to enabled (not-byassed)
684 ac->set_value (1.0, Controllable::NoGroup);
685 // ..and use host-provided hard-bypass
700 PluginInsert::enabled () const
702 if (_bypass_port == UINT32_MAX) {
703 return Processor::enabled ();
705 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
706 return (ac->get_value () > 0 && _pending_active);
711 PluginInsert::bypassable () const
713 if (_bypass_port == UINT32_MAX) {
716 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
718 return !ac->automation_playback ();
723 PluginInsert::enable_changed ()
729 PluginInsert::bypassable_changed ()
731 BypassableChanged ();
735 PluginInsert::write_immediate_event (size_t size, const uint8_t* buf)
738 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
739 if (!(*i)->write_immediate_event (size, buf)) {
747 PluginInsert::preset_load_set_value (uint32_t p, float v)
749 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, p));
754 if (ac->automation_state() & Play) {
759 ac->set_value (v, Controllable::NoGroup);
764 PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, samplecnt_t nframes, samplecnt_t offset) const
766 // TODO optimize: store "unconnected" in a fixed set.
767 // it only changes on reconfiguration.
768 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
769 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
771 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
772 mapped = true; // in-place Midi bypass
774 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
775 PinMappings::const_iterator i = out_map.find (pc);
776 if (i == out_map.end ()) {
779 const ChanMapping& outmap (i->second);
780 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
782 uint32_t idx = outmap.get (*t, o, &valid);
783 if (valid && idx == out) {
790 bufs.get (*t, out).silence (nframes, offset);
797 PluginInsert::connect_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes, samplecnt_t offset, bool with_auto)
799 // TODO: atomically copy maps & _no_inplace
800 PinMappings in_map (_in_map);
801 PinMappings out_map (_out_map);
802 ChanMapping thru_map (_thru_map);
803 if (_mapping_changed) { // ToDo use a counters, increment until match.
804 _no_inplace = check_inplace ();
805 _mapping_changed = false;
808 if (_latency_changed) {
809 /* delaylines are configured with the max possible latency (as reported by the plugin)
810 * so this won't allocate memory (unless the plugin lied about its max latency)
811 * It may still 'click' though, since the fixed delaylines are not de-clicked.
812 * Then again plugin-latency changes are not click-free to begin with.
814 * This is also worst case, there is currently no concept of per-stream latency.
816 * e.g. Two identical latent plugins:
817 * 1st plugin: process left (latent), bypass right.
818 * 2nd plugin: bypass left, process right (latent).
819 * -> currently this yields 2 times latency of the plugin,
821 _latency_changed = false;
822 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
825 if (_match.method == Split && !_no_inplace) {
826 // TODO: also use this optimization if one source-buffer
827 // feeds _all_ *connected* inputs.
828 // currently this is *first* buffer to all only --
829 // see PluginInsert::check_inplace
830 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
831 if (_configured_internal.get (*t) == 0) {
835 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
836 assert (valid && first_idx == 0); // check_inplace ensures this
837 /* copy the first stream's buffer contents to the others */
838 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
839 uint32_t idx = in_map[0].get (*t, i, &valid);
842 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
846 /* the copy operation produces a linear monotonic input map */
847 in_map[0] = ChanMapping (natural_input_streams ());
850 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
851 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
857 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
859 boost::shared_ptr<AutomationControl> c
860 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
862 if (c->list() && c->automation_playback()) {
865 const float val = c->list()->rt_safe_eval (start, valid);
868 /* This is the ONLY place where we are
870 * AutomationControl::set_value_unchecked(). We
871 * know that the control is in
872 * automation playback mode, so no
873 * check on writable() is required
874 * (which must be done in AutomationControl::set_value()
877 c->set_value_unchecked(val);
884 /* Calculate if, and how many samples we need to collect for analysis */
885 samplecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
886 _signal_analysis_collected_nframes);
887 if (nframes < collect_signal_nframes) { // we might not get all samples now
888 collect_signal_nframes = nframes;
891 if (collect_signal_nframes > 0) {
893 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
894 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
895 //std::cerr << "filling buffer with " << collect_signal_nframes << " samples at " << _signal_analysis_collected_nframes << std::endl;
897 _signal_analysis_inputs.set_count(input_streams());
899 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
900 _signal_analysis_inputs.get_audio(i).read_from (
902 collect_signal_nframes,
903 _signal_analysis_collected_nframes); // offset is for target buffer
908 if (is_channelstrip ()) {
909 if (_configured_in.n_audio() > 0) {
910 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
911 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
913 _plugins.front()->connect_and_run (bufs, start, end, speed, mb_in_map, mb_out_map, nframes, offset);
915 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
916 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
922 // TODO optimize -- build maps once.
924 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
925 ARDOUR::ChanMapping used_outputs;
927 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
929 /* build used-output map */
930 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
931 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
932 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
934 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
936 used_outputs.set (*t, out_idx, 1); // mark as used
941 /* copy thru data to outputs before processing in-place */
942 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
943 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
945 uint32_t in_idx = thru_map.get (*t, out, &valid);
946 uint32_t m = out + natural_input_streams ().get (*t);
948 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
949 used_outputs.set (*t, out, 1); // mark as used
951 used_outputs.get (*t, out, &valid);
953 /* the plugin is expected to write here, but may not :(
954 * (e.g. drumgizmo w/o kit loaded)
956 inplace_bufs.get (*t, m).silence (nframes);
963 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
965 ARDOUR::ChanMapping i_in_map (natural_input_streams());
966 ARDOUR::ChanMapping i_out_map (out_map[pc]);
967 ARDOUR::ChanCount mapped;
969 /* map inputs sequentially */
970 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
971 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
973 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
974 uint32_t m = mapped.get (*t);
976 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
978 inplace_bufs.get (*t, m).silence (nframes, offset);
980 mapped.set (*t, m + 1);
984 /* outputs are mapped to inplace_bufs after the inputs */
985 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
986 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
989 if ((*i)->connect_and_run (inplace_bufs, start, end, speed, i_in_map, i_out_map, nframes, offset)) {
994 /* all instances have completed, now copy data that was written
995 * and zero unconnected buffers */
996 ARDOUR::ChanMapping nonzero_out (used_outputs);
997 if (has_midi_bypass ()) {
998 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
1000 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1001 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
1003 used_outputs.get (*t, out, &valid);
1005 nonzero_out.get (*t, out, &valid);
1007 bufs.get (*t, out).silence (nframes, offset);
1010 uint32_t m = out + natural_input_streams ().get (*t);
1011 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
1016 /* in-place processing */
1018 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1019 if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) {
1023 // now silence unconnected outputs
1024 inplace_silence_unconnected (bufs, _out_map, nframes, offset);
1027 if (collect_signal_nframes > 0) {
1029 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
1030 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
1032 _signal_analysis_outputs.set_count(output_streams());
1034 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
1035 _signal_analysis_outputs.get_audio(i).read_from(
1037 collect_signal_nframes,
1038 _signal_analysis_collected_nframes); // offset is for target buffer
1041 _signal_analysis_collected_nframes += collect_signal_nframes;
1042 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
1044 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
1045 _signal_analysis_collect_nframes_max = 0;
1046 _signal_analysis_collected_nframes = 0;
1048 AnalysisDataGathered(&_signal_analysis_inputs,
1049 &_signal_analysis_outputs);
1053 if (_plugin_signal_latency != signal_latency ()) {
1054 _plugin_signal_latency = signal_latency ();
1060 PluginInsert::bypass (BufferSet& bufs, pframes_t nframes)
1062 /* bypass the plugin(s) not the whole processor.
1063 * -> use mappings just like connect_and_run
1066 // TODO: atomically copy maps & _no_inplace
1067 const ChanMapping in_map (no_sc_input_map ());
1068 const ChanMapping out_map (output_map ());
1069 if (_mapping_changed) {
1070 _no_inplace = check_inplace ();
1071 _mapping_changed = false;
1074 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
1075 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
1078 ChanMapping thru_map (_thru_map);
1080 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
1082 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1083 for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) {
1084 inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0);
1087 ARDOUR::ChanMapping used_outputs;
1089 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1090 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1092 uint32_t in_idx = thru_map.get (*t, out, &valid);
1094 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
1095 used_outputs.set (*t, out, 1); // mark as used
1099 // plugin no-op: assume every plugin has an internal identity map
1100 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1101 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1103 uint32_t src_idx = out_map.get_src (*t, out, &valid);
1107 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
1111 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
1112 used_outputs.set (*t, out, 1); // mark as used
1115 // now silence all unused outputs
1116 if (has_midi_bypass ()) {
1117 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
1119 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1120 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1122 used_outputs.get (*t, out, &valid);
1124 bufs.get (*t, out).silence (nframes, 0);
1129 if (_match.method == Split) {
1130 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1131 if (_configured_internal.get (*t) == 0) {
1134 // copy/feeds _all_ *connected* inputs, copy the first buffer
1136 uint32_t first_idx = in_map.get (*t, 0, &valid);
1137 assert (valid && first_idx == 0); // check_inplace ensures this
1138 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1139 uint32_t idx = in_map.get (*t, i, &valid);
1142 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0);
1148 // apply output map and/or monotonic but not identity i/o mappings
1149 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1150 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1152 uint32_t src_idx = out_map.get_src (*t, out, &valid);
1154 bufs.get (*t, out).silence (nframes, 0);
1157 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
1159 bufs.get (*t, out).silence (nframes, 0);
1162 if (in_idx != src_idx) {
1163 bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0);
1171 PluginInsert::silence (samplecnt_t nframes, samplepos_t start_sample)
1173 automation_run (start_sample, nframes); // evaluate automation only
1176 // XXX delaybuffers need to be offset by nframes
1180 _delaybuffers.flush ();
1182 ChanMapping in_map (natural_input_streams ());
1183 ChanMapping out_map (natural_output_streams ());
1184 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
1186 if (is_channelstrip ()) {
1187 if (_configured_in.n_audio() > 0) {
1188 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0);
1192 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1193 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0);
1198 PluginInsert::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool)
1201 // collect sidechain input for complete cycle (!)
1202 // TODO we need delaylines here for latency compensation
1203 _sidechain->run (bufs, start_sample, end_sample, speed, nframes, true);
1206 if (_pending_active) {
1207 /* run as normal if we are active or moving from inactive to active */
1209 if (_session.transport_rolling() || _session.bounce_processing()) {
1210 automate_and_run (bufs, start_sample, end_sample, speed, nframes);
1212 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1213 connect_and_run (bufs, start_sample, end_sample, speed, nframes, 0, lm.locked());
1217 // XXX should call ::silence() to run plugin(s) for consistent load.
1218 // We'll need to change this anyway when bypass can be automated
1219 bypass (bufs, nframes);
1220 automation_run (start_sample, nframes); // evaluate automation only
1221 _delaybuffers.flush ();
1224 _active = _pending_active;
1226 /* we have no idea whether the plugin generated silence or not, so mark
1227 * all buffers appropriately.
1232 PluginInsert::automate_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes)
1234 Evoral::ControlEvent next_event (0, 0.0f);
1235 samplecnt_t offset = 0;
1237 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1240 connect_and_run (bufs, start, end, speed, nframes, offset, false);
1244 /* map start back into loop-range, adjust end */
1245 map_loop_range (start, end);
1247 if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1249 /* no events have a time within the relevant range */
1251 connect_and_run (bufs, start, end, speed, nframes, offset, true);
1257 samplecnt_t cnt = min (((samplecnt_t) ceil (next_event.when) - start), (samplecnt_t) nframes);
1259 connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed
1265 map_loop_range (start, end);
1267 if (!find_next_event (start, end, next_event)) {
1272 /* cleanup anything that is left to do */
1275 connect_and_run (bufs, start, start + nframes, speed, nframes, offset, true);
1280 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1282 if (param.type() != PluginAutomation)
1285 if (_plugins.empty()) {
1286 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1288 abort(); /*NOTREACHED*/
1291 return _plugins[0]->default_value (param.id());
1296 PluginInsert::can_reset_all_parameters ()
1299 uint32_t params = 0;
1300 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1302 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1304 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1308 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1314 if (ac->automation_state() & Play) {
1319 return all && (params > 0);
1323 PluginInsert::reset_parameters_to_default ()
1327 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1329 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1331 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1335 const float dflt = _plugins[0]->default_value (cid);
1336 const float curr = _plugins[0]->get_parameter (cid);
1342 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1347 if (ac->automation_state() & Play) {
1352 ac->set_value (dflt, Controllable::NoGroup);
1357 boost::shared_ptr<Plugin>
1358 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1360 boost::shared_ptr<LadspaPlugin> lp;
1361 boost::shared_ptr<LuaProc> lua;
1363 boost::shared_ptr<LV2Plugin> lv2p;
1365 #ifdef WINDOWS_VST_SUPPORT
1366 boost::shared_ptr<WindowsVSTPlugin> vp;
1368 #ifdef LXVST_SUPPORT
1369 boost::shared_ptr<LXVSTPlugin> lxvp;
1371 #ifdef MACVST_SUPPORT
1372 boost::shared_ptr<MacVSTPlugin> mvp;
1374 #ifdef AUDIOUNIT_SUPPORT
1375 boost::shared_ptr<AUPlugin> ap;
1378 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1379 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1380 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1381 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1383 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1384 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1386 #ifdef WINDOWS_VST_SUPPORT
1387 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1388 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1390 #ifdef LXVST_SUPPORT
1391 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1392 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1394 #ifdef MACVST_SUPPORT
1395 } else if ((mvp = boost::dynamic_pointer_cast<MacVSTPlugin> (other)) != 0) {
1396 return boost::shared_ptr<Plugin> (new MacVSTPlugin (*mvp));
1398 #ifdef AUDIOUNIT_SUPPORT
1399 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1400 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1404 fatal << string_compose (_("programming error: %1"),
1405 X_("unknown plugin type in PluginInsert::plugin_factory"))
1407 abort(); /*NOTREACHED*/
1408 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1412 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1413 if (num < _in_map.size()) {
1414 bool changed = _in_map[num] != m;
1416 changed |= sanitize_maps ();
1418 PluginMapChanged (); /* EMIT SIGNAL */
1419 _mapping_changed = true;
1420 _session.set_dirty();
1426 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1427 if (num < _out_map.size()) {
1428 bool changed = _out_map[num] != m;
1430 changed |= sanitize_maps ();
1432 PluginMapChanged (); /* EMIT SIGNAL */
1433 _mapping_changed = true;
1434 _session.set_dirty();
1440 PluginInsert::set_thru_map (ChanMapping m) {
1441 bool changed = _thru_map != m;
1443 changed |= sanitize_maps ();
1445 PluginMapChanged (); /* EMIT SIGNAL */
1446 _mapping_changed = true;
1447 _session.set_dirty();
1452 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1453 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1455 if (_configured) { return false; }
1456 _configured_in = in;
1457 _configured_out = out;
1461 _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1466 PluginInsert::input_map () const
1470 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1471 ChanMapping m (i->second);
1472 const ChanMapping::Mappings& mp ((*i).second.mappings());
1473 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1474 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1475 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1484 PluginInsert::no_sc_input_map () const
1488 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1489 ChanMapping m (i->second);
1490 const ChanMapping::Mappings& mp ((*i).second.mappings());
1491 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1492 uint32_t ins = natural_input_streams().get(tm->first) - _cached_sidechain_pins.get(tm->first);
1493 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1494 if (i->first < ins) {
1495 rv.set (tm->first, i->first + pc * ins, i->second);
1504 PluginInsert::output_map () const
1508 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1509 ChanMapping m (i->second);
1510 const ChanMapping::Mappings& mp ((*i).second.mappings());
1511 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1512 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1513 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1517 if (has_midi_bypass ()) {
1518 rv.set (DataType::MIDI, 0, 0);
1525 PluginInsert::has_midi_bypass () const
1527 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1528 && natural_output_streams ().n_midi () == 0) {
1535 PluginInsert::has_midi_thru () const
1537 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1538 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1546 PluginInsert::is_channelstrip () const {
1547 return _plugins.front()->is_channelstrip();
1552 PluginInsert::check_inplace ()
1554 bool inplace_ok = !_plugins.front()->inplace_broken ();
1556 if (_thru_map.n_total () > 0) {
1557 // TODO once midi-bypass is part of the mapping, ignore it
1561 if (_match.method == Split && inplace_ok) {
1562 assert (get_count() == 1);
1563 assert (_in_map.size () == 1);
1564 if (!_out_map[0].is_monotonic ()) {
1567 if (_configured_internal != _configured_in) {
1568 /* no sidechain -- TODO we could allow this with
1569 * some more logic in PluginInsert::connect_and_run().
1571 * PluginInsert::reset_map() already maps it.
1576 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1577 if (_configured_internal.get (*t) == 0) {
1581 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1582 if (!valid || first_idx != 0) {
1583 // so far only allow to copy the *first* stream's buffer to others
1586 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1587 uint32_t idx = _in_map[0].get (*t, i, &valid);
1588 if (valid && idx != first_idx) {
1597 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1602 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1603 if (!_in_map[pc].is_monotonic ()) {
1606 if (!_out_map[pc].is_monotonic ()) {
1612 /* check if every output is fed by the corresponding input
1614 * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2
1615 * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1)
1617 * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
1619 ChanMapping in_map (input_map ());
1620 const ChanMapping::Mappings out_m (output_map ().mappings ());
1621 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1622 for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1623 /* src-pin: c->first, out-port: c->second */
1625 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1626 if (valid && in_port != c->second) {
1634 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1635 return !inplace_ok; // no-inplace
1639 PluginInsert::sanitize_maps ()
1641 bool changed = false;
1642 /* strip dead wood */
1643 PinMappings new_ins;
1644 PinMappings new_outs;
1645 ChanMapping new_thru;
1647 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1649 ChanMapping new_out;
1650 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1651 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1653 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1654 if (valid && idx < _configured_internal.get (*t)) {
1655 new_in.set (*t, i, idx);
1658 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1660 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1661 if (valid && idx < _configured_out.get (*t)) {
1662 new_out.set (*t, o, idx);
1666 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1669 new_ins[pc] = new_in;
1670 new_outs[pc] = new_out;
1673 /* prevent dup output assignments */
1674 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1675 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1676 bool mapped = false;
1677 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1679 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1680 if (valid && mapped) {
1681 new_outs[pc].unset (*t, idx);
1689 /* remove excess thru */
1690 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1691 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1693 uint32_t idx = _thru_map.get (*t, o, &valid);
1694 if (valid && idx < _configured_internal.get (*t)) {
1695 new_thru.set (*t, o, idx);
1700 /* prevent out + thru, existing plugin outputs override thru */
1701 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1702 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1703 bool mapped = false;
1705 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1706 new_outs[pc].get_src (*t, o, &mapped);
1707 if (mapped) { break; }
1709 if (!mapped) { continue; }
1710 uint32_t idx = new_thru.get (*t, o, &valid);
1712 new_thru.unset (*t, idx);
1717 if (has_midi_bypass ()) {
1718 // TODO: include midi-bypass in the thru set,
1719 // remove dedicated handling.
1720 new_thru.unset (DataType::MIDI, 0);
1723 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1727 _out_map = new_outs;
1728 _thru_map = new_thru;
1734 PluginInsert::reset_map (bool emit)
1736 const PinMappings old_in (_in_map);
1737 const PinMappings old_out (_out_map);
1741 _thru_map = ChanMapping ();
1743 /* build input map */
1744 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1745 uint32_t sc = 0; // side-chain round-robin (all instances)
1747 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1748 const uint32_t nis = natural_input_streams ().get(*t);
1749 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1751 /* SC inputs are last in the plugin-insert.. */
1752 const uint32_t sc_start = _configured_in.get (*t);
1753 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1754 /* ...but may not be at the end of the plugin ports.
1755 * in case the side-chain is not the last port, shift connections back.
1756 * and connect to side-chain
1759 uint32_t ic = 0; // split inputs
1760 const uint32_t cend = _configured_in.get (*t);
1762 for (uint32_t in = 0; in < nis; ++in) {
1763 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1764 if (iod.is_sidechain) {
1765 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1766 if (sc_len > 0) {// side-chain may be hidden
1767 _in_map[pc].set (*t, in, sc_start + sc);
1768 sc = (sc + 1) % sc_len;
1772 if (_match.method == Split) {
1773 if (cend == 0) { continue; }
1774 if (_strict_io && ic + stride * pc >= cend) {
1777 /* connect *no* sidechain sinks in round-robin fashion */
1778 _in_map[pc].set (*t, in, ic + stride * pc);
1779 if (_strict_io && (ic + 1) == cend) {
1782 ic = (ic + 1) % cend;
1784 uint32_t s = in - shift;
1785 if (stride * pc + s < cend) {
1786 _in_map[pc].set (*t, in, s + stride * pc);
1794 /* build output map */
1796 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1797 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1798 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1799 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1804 if (old_in == _in_map && old_out == _out_map) {
1808 PluginMapChanged (); /* EMIT SIGNAL */
1809 _mapping_changed = true;
1810 _session.set_dirty();
1816 PluginInsert::configure_io (ChanCount in, ChanCount out)
1818 Match old_match = _match;
1820 ChanCount old_internal;
1824 old_pins = natural_input_streams();
1825 old_in = _configured_in;
1826 old_out = _configured_out;
1827 old_internal = _configured_internal;
1829 _configured_in = in;
1830 _configured_internal = in;
1831 _configured_out = out;
1834 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1835 * (currently _sidechain->configure_io always succeeds
1836 * since Processor::configure_io() succeeds)
1838 if (!_sidechain->configure_io (in, out)) {
1839 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1842 _configured_internal += _sidechain->input()->n_ports();
1844 // include (static_cast<Route*>owner())->name() ??
1845 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1848 /* get plugin configuration */
1849 _match = private_can_support_io_configuration (in, out);
1851 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1853 DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
1854 DEBUG_STR_APPEND(a, _match);
1855 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1859 /* set the matching method and number of plugins that we will use to meet this configuration */
1860 if (set_count (_match.plugins) == false) {
1861 PluginIoReConfigure (); /* EMIT SIGNAL */
1862 _configured = false;
1866 /* configure plugins */
1867 switch (_match.method) {
1870 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1871 PluginIoReConfigure (); /* EMIT SIGNAL */
1872 _configured = false;
1878 ChanCount din (_configured_internal);
1879 ChanCount dout (din); // hint
1881 if (_custom_sinks.n_total () > 0) {
1882 din = _custom_sinks;
1885 } else if (_preset_out.n_audio () > 0) {
1886 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1887 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1888 dout.set (DataType::AUDIO, 2);
1890 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1892 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1893 bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1895 if (useins.n_audio() == 0) {
1898 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1900 if (_plugins.front()->configure_io (useins, dout) == false) {
1901 PluginIoReConfigure (); /* EMIT SIGNAL */
1902 _configured = false;
1906 _custom_sinks = din;
1911 if (_plugins.front()->configure_io (in, out) == false) {
1912 PluginIoReConfigure (); /* EMIT SIGNAL */
1913 _configured = false;
1919 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",
1921 _configured ? "Y" : "N",
1922 _maps_from_state ? "Y" : "N",
1923 old_in == in ? "==" : "!=",
1924 old_out == out ? "==" : "!=",
1925 old_pins == natural_input_streams () ? "==" : "!=",
1926 old_match.method == _match.method ? "==" : "!=",
1927 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1928 _in_map.size() == get_count () ? "==" : "!=",
1929 _out_map.size() == get_count () ? "==" : "!="
1932 bool mapping_changed = false;
1933 if (old_in == in && old_out == out
1935 && old_pins == natural_input_streams ()
1936 && old_match.method == _match.method
1937 && old_match.custom_cfg == _match.custom_cfg
1938 && _in_map.size() == _out_map.size()
1939 && _in_map.size() == get_count ()
1941 /* If the configuration has not changed, keep the mapping */
1942 mapping_changed = sanitize_maps ();
1943 } else if (_match.custom_cfg && _configured) {
1944 /* don't touch the map in manual mode */
1945 mapping_changed = sanitize_maps ();
1948 if (is_channelstrip ()) {
1949 /* fake channel map - for wire display */
1952 _thru_map = ChanMapping ();
1953 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1954 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1955 /* set "thru" map for in-place forward of audio */
1956 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1957 _thru_map.set (DataType::AUDIO, i, i);
1959 /* and midi (after implicit 1st channel bypass) */
1960 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1961 _thru_map.set (DataType::MIDI, i, i);
1965 if (_maps_from_state && old_in == in && old_out == out) {
1966 mapping_changed = true;
1969 /* generate a new mapping */
1970 mapping_changed = reset_map (false);
1972 _maps_from_state = false;
1975 if (mapping_changed) {
1976 PluginMapChanged (); /* EMIT SIGNAL */
1979 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1982 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1983 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1985 DEBUG_STR_APPEND(a, "----><----\n");
1987 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1988 DEBUG_STR_APPEND(a, " * Inputs:\n");
1989 DEBUG_STR_APPEND(a, _in_map[pc]);
1990 DEBUG_STR_APPEND(a, " * Outputs:\n");
1991 DEBUG_STR_APPEND(a, _out_map[pc]);
1993 DEBUG_STR_APPEND(a, " * Thru:\n");
1994 DEBUG_STR_APPEND(a, _thru_map);
1995 DEBUG_STR_APPEND(a, "-------->>--------\n");
1996 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
2001 _no_inplace = check_inplace ();
2002 _mapping_changed = false;
2004 /* only the "noinplace_buffers" thread buffers need to be this large,
2005 * this can be optimized. other buffers are fine with
2006 * ChanCount::max (natural_input_streams (), natural_output_streams())
2007 * and route.cc's max (configured_in, configured_out)
2009 * no-inplace copies "thru" outputs (to emulate in-place) for
2010 * all outputs (to prevent overwrite) into a temporary space
2011 * which also holds input buffers (in case the plugin does process
2012 * in-place and overwrites those).
2014 * this buffers need to be at least as
2015 * natural_input_streams () + possible outputs.
2017 * sidechain inputs add a constraint on the input:
2018 * configured input + sidechain (=_configured_internal)
2020 * NB. this also satisfies
2021 * max (natural_input_streams(), natural_output_streams())
2022 * which is needed for silence runs
2024 _required_buffers = ChanCount::max (_configured_internal,
2025 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
2027 if (old_in != in || old_out != out || old_internal != _configured_internal
2028 || old_pins != natural_input_streams ()
2029 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
2031 PluginIoReConfigure (); /* EMIT SIGNAL */
2034 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
2035 _latency_changed = true;
2037 // we don't know the analysis window size, so we must work with the
2038 // current buffer size here. each request for data fills in these
2039 // buffers and the analyser makes sure it gets enough data for the
2041 session().ensure_buffer_set (_signal_analysis_inputs, in);
2042 _signal_analysis_inputs.set_count (in);
2044 session().ensure_buffer_set (_signal_analysis_outputs, out);
2045 _signal_analysis_outputs.set_count (out);
2047 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
2050 return Processor::configure_io (in, out);
2053 /** Decide whether this PluginInsert can support a given IO configuration.
2054 * To do this, we run through a set of possible solutions in rough order of
2057 * @param in Required input channel count.
2058 * @param out Filled in with the output channel count if we return true.
2059 * @return true if the given IO configuration can be supported.
2062 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
2065 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
2067 return private_can_support_io_configuration (in, out).method != Impossible;
2071 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
2073 if (!_custom_cfg && _preset_out.n_audio () > 0) {
2074 // preseed hint (for variable i/o)
2075 out.set (DataType::AUDIO, _preset_out.n_audio ());
2078 Match rv = internal_can_support_io_configuration (in, out);
2080 if (!_custom_cfg && _preset_out.n_audio () > 0) {
2081 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
2082 out.set (DataType::AUDIO, _preset_out.n_audio ());
2087 /** A private version of can_support_io_configuration which returns the method
2088 * by which the configuration can be matched, rather than just whether or not
2092 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
2094 if (_plugins.empty()) {
2099 if (is_channelstrip ()) {
2101 return Match (ExactMatch, 1);
2105 /* if a user specified a custom cfg, so be it. */
2107 PluginInfoPtr info = _plugins.front()->get_info();
2109 if (info->reconfigurable_io()) {
2110 return Match (Delegate, 1, _strict_io, true);
2112 return Match (ExactMatch, get_count(), _strict_io, true);
2116 /* try automatic configuration */
2117 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
2119 PluginInfoPtr info = _plugins.front()->get_info();
2120 ChanCount inputs = info->n_inputs;
2121 ChanCount outputs = info->n_outputs;
2123 /* handle case strict-i/o */
2124 if (_strict_io && m.method != Impossible) {
2127 /* special case MIDI instruments */
2128 if (is_instrument ()) {
2129 // output = midi-bypass + at most master-out channels.
2130 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
2131 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
2132 out = ChanCount::min (out, max_out);
2133 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
2139 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
2140 /* replicate processor to match output count (generators and such)
2141 * at least enough to feed every output port. */
2142 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
2143 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2144 uint32_t nout = outputs.get (*t);
2145 if (nout == 0 || inx.get(*t) == 0) { continue; }
2146 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
2149 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
2150 return Match (Replicate, f, _strict_io);
2161 if (m.method != Impossible) {
2165 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2167 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
2169 if (info->reconfigurable_io()) {
2172 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2173 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2174 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
2176 // houston, we have a problem.
2177 return Match (Impossible, 0);
2180 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2181 return Match (Delegate, 1, _strict_io);
2184 ChanCount midi_bypass;
2185 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2186 midi_bypass.set (DataType::MIDI, 1);
2189 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
2191 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2192 uint32_t nin = ns_inputs.get (*t);
2193 uint32_t nout = outputs.get (*t);
2194 if (nin == 0 || inx.get(*t) == 0) { continue; }
2195 // prefer floor() so the count won't overly increase IFF (nin < nout)
2196 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
2198 if (f > 0 && outputs * f >= _configured_out) {
2199 out = outputs * f + midi_bypass;
2200 return Match (Replicate, f, _strict_io);
2203 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
2205 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2206 uint32_t nin = ns_inputs.get (*t);
2207 if (nin == 0 || inx.get(*t) == 0) { continue; }
2208 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2211 out = outputs * f + midi_bypass;
2212 return Match (Replicate, f, _strict_io);
2215 // add at least as many plugins needed to connect all inputs
2217 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2218 uint32_t nin = inputs.get (*t);
2219 if (nin == 0 || inx.get(*t) == 0) { continue; }
2220 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2222 out = outputs * f + midi_bypass;
2223 return Match (Replicate, f, _strict_io);
2226 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
2228 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
2230 if (_plugins.empty()) {
2234 PluginInfoPtr info = _plugins.front()->get_info();
2235 ChanCount in; in += inx;
2236 ChanCount midi_bypass;
2238 if (info->reconfigurable_io()) {
2239 /* Plugin has flexible I/O, so delegate to it
2240 * pre-seed outputs, plugin tries closest match
2243 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2244 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2245 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
2247 return Match (Impossible, 0);
2250 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2251 return Match (Delegate, 1);
2254 ChanCount inputs = info->n_inputs;
2255 ChanCount outputs = info->n_outputs;
2256 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2258 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2259 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
2260 midi_bypass.set (DataType::MIDI, 1);
2262 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
2263 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
2264 in.set(DataType::MIDI, 0);
2267 // add internally provided sidechain ports
2268 ChanCount insc = in + sidechain_input_ports ();
2270 bool no_inputs = true;
2271 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2272 if (inputs.get (*t) != 0) {
2279 /* no inputs so we can take any input configuration since we throw it away */
2280 out = outputs + midi_bypass;
2281 return Match (NoInputs, 1);
2284 /* Plugin inputs match requested inputs + side-chain-ports exactly */
2285 if (inputs == insc) {
2286 out = outputs + midi_bypass;
2287 return Match (ExactMatch, 1);
2290 /* Plugin inputs matches without side-chain-pins */
2291 if (ns_inputs == in) {
2292 out = outputs + midi_bypass;
2293 return Match (ExactMatch, 1);
2296 /* We may be able to run more than one copy of the plugin within this insert
2297 to cope with the insert having more inputs than the plugin.
2298 We allow replication only for plugins with either zero or 1 inputs and outputs
2299 for every valid data type.
2303 bool can_replicate = true;
2304 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2306 // ignore side-chains
2307 uint32_t nin = ns_inputs.get (*t);
2309 // No inputs of this type
2310 if (nin == 0 && in.get(*t) == 0) {
2314 if (nin != 1 || outputs.get (*t) != 1) {
2315 can_replicate = false;
2319 // Potential factor not set yet
2321 f = in.get(*t) / nin;
2324 // Factor for this type does not match another type, can not replicate
2325 if (f != (in.get(*t) / nin)) {
2326 can_replicate = false;
2331 if (can_replicate && f > 0) {
2332 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2333 out.set (*t, outputs.get(*t) * f);
2336 return Match (Replicate, f);
2339 /* If the processor has exactly one input of a given type, and
2340 the plugin has more, we can feed the single processor input
2341 to some or all of the plugin inputs. This is rather
2342 special-case-y, but the 1-to-many case is by far the
2343 simplest. How do I split thy 2 processor inputs to 3
2344 plugin inputs? Let me count the ways ...
2347 bool can_split = true;
2348 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2350 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2351 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2353 if (!can_split_type && !nothing_to_do_for_type) {
2359 out = outputs + midi_bypass;
2360 return Match (Split, 1);
2363 /* If the plugin has more inputs than we want, we can `hide' some of them
2364 by feeding them silence.
2367 bool could_hide = false;
2368 bool cannot_hide = false;
2369 ChanCount hide_channels;
2371 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2372 if (inputs.get(*t) > in.get(*t)) {
2373 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2374 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2376 } else if (inputs.get(*t) < in.get(*t)) {
2377 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2382 if (could_hide && !cannot_hide) {
2383 out = outputs + midi_bypass;
2384 return Match (Hide, 1, false, false, hide_channels);
2387 return Match (Impossible, 0);
2392 PluginInsert::state ()
2394 XMLNode& node = Processor::state ();
2396 node.set_property("type", _plugins[0]->state_node_name());
2397 node.set_property("unique-id", _plugins[0]->unique_id());
2398 node.set_property("count", (uint32_t)_plugins.size());
2400 /* remember actual i/o configuration (for later placeholder
2401 * in case the plugin goes missing) */
2402 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2403 node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2404 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2405 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2407 /* save custom i/o config */
2408 node.set_property("custom", _custom_cfg);
2409 for (uint32_t pc = 0; pc < get_count(); ++pc) {
2411 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2412 node.add_child_nocopy (* _in_map[pc].state (tmp));
2413 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2414 node.add_child_nocopy (* _out_map[pc].state (tmp));
2416 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2419 node.add_child_nocopy (_sidechain->get_state ());
2422 _plugins[0]->set_insert_id(this->id());
2423 node.add_child_nocopy (_plugins[0]->get_state());
2425 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2426 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2428 node.add_child_nocopy (ac->get_state());
2436 PluginInsert::set_control_ids (const XMLNode& node, int version)
2438 const XMLNodeList& nlist = node.children();
2439 XMLNodeConstIterator iter;
2440 set<Evoral::Parameter>::const_iterator p;
2442 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2443 if ((*iter)->name() == Controllable::xml_node_name) {
2445 uint32_t p = (uint32_t)-1;
2448 if ((*iter)->get_property (X_("symbol"), str)) {
2449 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2451 p = lv2plugin->port_index(str.c_str());
2455 if (p == (uint32_t)-1) {
2456 (*iter)->get_property (X_("parameter"), p);
2459 if (p != (uint32_t)-1) {
2461 /* this may create the new controllable */
2463 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2465 #ifndef NO_PLUGIN_STATE
2469 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2471 ac->set_state (**iter, version);
2480 PluginInsert::set_state(const XMLNode& node, int version)
2482 XMLNodeList nlist = node.children();
2483 XMLNodeIterator niter;
2484 XMLPropertyList plist;
2485 ARDOUR::PluginType type;
2488 if (!node.get_property ("type", str)) {
2489 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2493 if (str == X_("ladspa") || str == X_("Ladspa")) { /* handle old school sessions */
2494 type = ARDOUR::LADSPA;
2495 } else if (str == X_("lv2")) {
2497 } else if (str == X_("windows-vst")) {
2498 type = ARDOUR::Windows_VST;
2499 } else if (str == X_("lxvst")) {
2500 type = ARDOUR::LXVST;
2501 } else if (str == X_("mac-vst")) {
2502 type = ARDOUR::MacVST;
2503 } else if (str == X_("audiounit")) {
2504 type = ARDOUR::AudioUnit;
2505 } else if (str == X_("luaproc")) {
2508 error << string_compose (_("unknown plugin type %1 in plugin insert state"), str) << endmsg;
2512 XMLProperty const * prop = node.property ("unique-id");
2515 #ifdef WINDOWS_VST_SUPPORT
2516 /* older sessions contain VST plugins with only an "id" field. */
2517 if (type == ARDOUR::Windows_VST) {
2518 prop = node.property ("id");
2522 #ifdef LXVST_SUPPORT
2523 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2524 if (type == ARDOUR::LXVST) {
2525 prop = node.property ("id");
2532 error << _("Plugin has no unique ID field") << endmsg;
2537 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2538 bool any_vst = false;
2540 /* treat VST plugins equivalent if they have the same uniqueID
2541 * allow to move sessions windows <> linux */
2542 #ifdef LXVST_SUPPORT
2543 if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::MacVST)) {
2544 type = ARDOUR::LXVST;
2545 plugin = find_plugin (_session, prop->value(), type);
2546 if (plugin) { any_vst = true; }
2550 #ifdef WINDOWS_VST_SUPPORT
2551 if (plugin == 0 && (type == ARDOUR::LXVST || type == ARDOUR::MacVST)) {
2552 type = ARDOUR::Windows_VST;
2553 plugin = find_plugin (_session, prop->value(), type);
2554 if (plugin) { any_vst = true; }
2558 #ifdef MACVST_SUPPORT
2559 if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::LXVST)) {
2560 type = ARDOUR::MacVST;
2561 plugin = find_plugin (_session, prop->value(), type);
2562 if (plugin) { any_vst = true; }
2566 if (plugin == 0 && type == ARDOUR::Lua) {
2567 /* unique ID (sha1 of script) was not found,
2568 * load the plugin from the serialized version in the
2569 * session-file instead.
2571 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2572 XMLNode *ls = node.child (lp->state_node_name().c_str());
2574 lp->set_script_from_state (*ls);
2580 error << string_compose(
2581 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2582 "Perhaps it was removed or moved since it was last used."),
2588 // The name of the PluginInsert comes from the plugin, nothing else
2589 _name = plugin->get_info()->name;
2593 // Processor::set_state() will set this, but too late
2594 // for it to be available when setting up plugin
2595 // state. We can't call Processor::set_state() until
2596 // the plugins themselves are created and added.
2600 if (_plugins.empty()) {
2601 /* if we are adding the first plugin, we will need to set
2602 up automatable controls.
2604 add_plugin (plugin);
2605 create_automatable_parameters ();
2606 set_control_ids (node, version);
2609 node.get_property ("count", count);
2611 if (_plugins.size() != count) {
2612 for (uint32_t n = 1; n < count; ++n) {
2613 add_plugin (plugin_factory (plugin));
2617 Processor::set_state (node, version);
2619 PBD::ID new_id = this->id();
2620 PBD::ID old_id = this->id();
2622 node.get_property ("id", old_id);
2624 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2626 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2627 and set all plugins to the same state.
2630 if ( ((*niter)->name() == plugin->state_node_name())
2631 || (any_vst && ((*niter)->name() == "lxvst" || (*niter)->name() == "windows-vst" || (*niter)->name() == "mac-vst"))
2634 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2635 /* Plugin state can include external files which are named after the ID.
2637 * If regenerate_xml_or_string_ids() is set, the ID will already have
2638 * been changed, so we need to use the old ID from the XML to load the
2639 * state and then update the ID.
2641 * When copying a plugin-state, route_ui takes care of of updating the ID,
2642 * but we need to call set_insert_id() to clear the cached plugin-state
2643 * and force a change.
2645 if (!regenerate_xml_or_string_ids ()) {
2646 (*i)->set_insert_id (new_id);
2648 (*i)->set_insert_id (old_id);
2651 (*i)->set_state (**niter, version);
2653 if (regenerate_xml_or_string_ids ()) {
2654 (*i)->set_insert_id (new_id);
2658 /* when copying plugin state, notify UI */
2659 for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li) {
2660 boost::shared_ptr<PBD::Controllable> c = boost::dynamic_pointer_cast<PBD::Controllable> (li->second);
2662 c->Changed (false, Controllable::NoGroup); /* EMIT SIGNAL */
2670 if (version < 3000) {
2672 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2673 this is all handled by Automatable
2676 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2677 if ((*niter)->name() == "Redirect") {
2678 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2679 Processor::set_state (**niter, version);
2684 set_parameter_state_2X (node, version);
2687 node.get_property (X_("custom"), _custom_cfg);
2689 uint32_t in_maps = 0;
2690 uint32_t out_maps = 0;
2691 XMLNodeList kids = node.children ();
2692 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2693 if ((*i)->name() == X_("ConfiguredInput")) {
2694 _configured_in = ChanCount(**i);
2696 if ((*i)->name() == X_("CustomSinks")) {
2697 _custom_sinks = ChanCount(**i);
2699 if ((*i)->name() == X_("ConfiguredOutput")) {
2700 _custom_out = ChanCount(**i);
2701 _configured_out = ChanCount(**i);
2703 if ((*i)->name() == X_("PresetOutput")) {
2704 _preset_out = ChanCount(**i);
2706 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2707 long pc = atol (&((*i)->name().c_str()[9]));
2708 if (pc >= 0 && pc <= (long) get_count()) {
2709 _in_map[pc] = ChanMapping (**i);
2713 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2714 long pc = atol (&((*i)->name().c_str()[10]));
2715 if (pc >= 0 && pc <= (long) get_count()) {
2716 _out_map[pc] = ChanMapping (**i);
2720 if ((*i)->name () == "ThruMap") {
2721 _thru_map = ChanMapping (**i);
2724 // sidechain is a Processor (IO)
2725 if ((*i)->name () == Processor::state_node_name) {
2729 if (!regenerate_xml_or_string_ids ()) {
2730 _sidechain->set_state (**i, version);
2735 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2736 _maps_from_state = true;
2739 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2743 (*i)->deactivate ();
2747 PluginConfigChanged (); /* EMIT SIGNAL */
2752 PluginInsert::update_id (PBD::ID id)
2755 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2756 (*i)->set_insert_id (id);
2761 PluginInsert::set_owner (SessionObject* o)
2763 Processor::set_owner (o);
2764 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2765 (*i)->set_owner (o);
2770 PluginInsert::set_state_dir (const std::string& d)
2772 // state() only saves the state of the first plugin
2773 _plugins[0]->set_state_dir (d);
2777 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2779 XMLNodeList nlist = node.children();
2780 XMLNodeIterator niter;
2782 /* look for port automation node */
2784 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2786 if ((*niter)->name() != port_automation_node_name) {
2791 XMLNodeConstIterator iter;
2795 cnodes = (*niter)->children ("port");
2797 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2801 if (!child->get_property("number", port_id)) {
2802 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2806 if (port_id >= _plugins[0]->parameter_count()) {
2807 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2811 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2812 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2814 if (c && c->alist()) {
2815 if (!child->children().empty()) {
2816 c->alist()->set_state (*child->children().front(), version);
2819 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2829 boost::shared_ptr<ReadOnlyControl>
2830 PluginInsert::control_output (uint32_t num) const
2832 CtrlOutMap::const_iterator i = _control_outputs.find (num);
2833 if (i == _control_outputs.end ()) {
2834 return boost::shared_ptr<ReadOnlyControl> ();
2841 PluginInsert::describe_parameter (Evoral::Parameter param)
2843 if (param.type() == PluginAutomation) {
2844 return _plugins[0]->describe_parameter (param);
2845 } else if (param.type() == PluginPropertyAutomation) {
2846 boost::shared_ptr<AutomationControl> c(automation_control(param));
2847 if (c && !c->desc().label.empty()) {
2848 return c->desc().label;
2851 return Automatable::describe_parameter(param);
2855 PluginInsert::signal_latency() const
2857 if (!_pending_active) {
2860 if (_user_latency) {
2861 return _user_latency;
2864 return _plugins[0]->signal_latency ();
2868 PluginInsert::type ()
2870 return plugin()->get_info()->type;
2873 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2874 const Evoral::Parameter& param,
2875 const ParameterDescriptor& desc,
2876 boost::shared_ptr<AutomationList> list)
2877 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2882 list->set_interpolation(Evoral::ControlList::Discrete);
2887 /** @param val `user' value */
2890 PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2892 /* FIXME: probably should be taking out some lock here.. */
2894 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2895 (*i)->set_parameter (_list->parameter().id(), user_val);
2898 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2900 iasp->set_parameter (_list->parameter().id(), user_val);
2903 AutomationControl::actually_set_value (user_val, group_override);
2907 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2909 AutomationControl::actually_set_value (user_val, Controllable::NoGroup);
2913 PluginInsert::PluginControl::get_state ()
2915 XMLNode& node (AutomationControl::get_state());
2916 node.set_property (X_("parameter"), parameter().id());
2918 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2920 node.set_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2927 /** @return `user' val */
2929 PluginInsert::PluginControl::get_value () const
2931 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2937 return plugin->get_parameter (_list->parameter().id());
2940 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2941 const Evoral::Parameter& param,
2942 const ParameterDescriptor& desc,
2943 boost::shared_ptr<AutomationList> list)
2944 : AutomationControl (p->session(), param, desc, list)
2950 PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd)
2952 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2953 This is lossy, but better than nothing until Ardour's automation system
2954 can handle various datatypes all the way down. */
2955 const Variant value(_desc.datatype, user_val);
2956 if (value.type() == Variant::NOTHING) {
2957 error << "set_value(double) called for non-numeric property" << endmsg;
2961 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2962 (*i)->set_property(_list->parameter().id(), value);
2967 AutomationControl::actually_set_value (user_val, gcd);
2971 PluginInsert::PluginPropertyControl::get_state ()
2973 XMLNode& node (AutomationControl::get_state());
2974 node.set_property (X_("property"), parameter().id());
2975 node.remove_property (X_("value"));
2981 PluginInsert::PluginPropertyControl::get_value () const
2983 return _value.to_double();
2986 boost::shared_ptr<Plugin>
2987 PluginInsert::get_impulse_analysis_plugin()
2989 boost::shared_ptr<Plugin> ret;
2990 if (_impulseAnalysisPlugin.expired()) {
2991 // LV2 in particular uses various _session params
2992 // during init() -- most notably block_size..
2994 ret = plugin_factory(_plugins[0]);
2995 ChanCount out (internal_output_streams ());
2996 if (ret->get_info ()->reconfigurable_io ()) {
2997 // populate get_info ()->n_inputs and ->n_outputs
2999 ret->can_support_io_configuration (internal_input_streams (), out, &useins);
3000 assert (out == internal_output_streams ());
3002 ret->configure_io (internal_input_streams (), out);
3003 ret->set_owner (_owner);
3004 _impulseAnalysisPlugin = ret;
3006 ret = _impulseAnalysisPlugin.lock();
3013 PluginInsert::collect_signal_for_analysis (samplecnt_t nframes)
3015 // called from outside the audio thread, so this should be safe
3016 // only do audio as analysis is (currently) only for audio plugins
3017 _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes);
3018 _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
3020 _signal_analysis_collected_nframes = 0;
3021 _signal_analysis_collect_nframes_max = nframes;
3024 /** Add a plugin to our list */
3026 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
3028 plugin->set_insert_id (this->id());
3029 plugin->set_owner (_owner);
3031 if (_plugins.empty()) {
3032 /* first (and probably only) plugin instance - connect to relevant signals */
3034 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
3035 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
3036 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
3037 _custom_sinks = plugin->get_info()->n_inputs;
3038 // cache sidechain port count
3039 _cached_sidechain_pins.reset ();
3040 const ChanCount& nis (plugin->get_info()->n_inputs);
3041 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3042 for (uint32_t in = 0; in < nis.get (*t); ++in) {
3043 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
3044 if (iod.is_sidechain) {
3045 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
3050 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT)
3051 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
3053 vst->set_insert (this, _plugins.size ());
3057 _plugins.push_back (plugin);
3061 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
3064 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3065 if (! (*i)->load_preset (pr)) {
3073 PluginInsert::realtime_handle_transport_stopped ()
3075 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3076 (*i)->realtime_handle_transport_stopped ();
3081 PluginInsert::realtime_locate ()
3083 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3084 (*i)->realtime_locate ();
3089 PluginInsert::monitoring_changed ()
3091 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
3092 (*i)->monitoring_changed ();
3097 PluginInsert::latency_changed ()
3099 // this is called in RT context, LatencyChanged is emitted after run()
3100 _latency_changed = true;
3101 // XXX This also needs a proper API not an owner() hack.
3103 static_cast<Route*>(owner ())->processor_latency_changed (); /* EMIT SIGNAL */
3107 PluginInsert::start_touch (uint32_t param_id)
3109 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
3111 // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0
3112 ac->start_touch (session().audible_sample());
3117 PluginInsert::end_touch (uint32_t param_id)
3119 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
3121 // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0
3122 ac->stop_touch (session().audible_sample());
3126 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
3129 case PluginInsert::Impossible: o << "Impossible"; break;
3130 case PluginInsert::Delegate: o << "Delegate"; break;
3131 case PluginInsert::NoInputs: o << "NoInputs"; break;
3132 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
3133 case PluginInsert::Replicate: o << "Replicate"; break;
3134 case PluginInsert::Split: o << "Split"; break;
3135 case PluginInsert::Hide: o << "Hide"; break;
3137 o << " cnt: " << m.plugins
3138 << (m.strict_io ? " strict-io" : "")
3139 << (m.custom_cfg ? " custom-cfg" : "");
3140 if (m.method == PluginInsert::Hide) {
3141 o << " hide: " << m.hide;