2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "libardour-config.h"
26 #include "pbd/failed_constructor.h"
27 #include "pbd/xml++.h"
28 #include "pbd/convert.h"
30 #include "ardour/audio_buffer.h"
31 #include "ardour/automation_list.h"
32 #include "ardour/buffer_set.h"
33 #include "ardour/debug.h"
34 #include "ardour/event_type_map.h"
35 #include "ardour/ladspa_plugin.h"
36 #include "ardour/luaproc.h"
37 #include "ardour/plugin.h"
38 #include "ardour/plugin_insert.h"
39 #include "ardour/port.h"
42 #include "ardour/lv2_plugin.h"
45 #ifdef WINDOWS_VST_SUPPORT
46 #include "ardour/windows_vst_plugin.h"
50 #include "ardour/lxvst_plugin.h"
53 #ifdef AUDIOUNIT_SUPPORT
54 #include "ardour/audio_unit.h"
57 #include "ardour/session.h"
58 #include "ardour/types.h"
63 using namespace ARDOUR;
66 const string PluginInsert::port_automation_node_name = "PortAutomation";
68 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
69 : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
70 , _sc_playback_latency (0)
71 , _sc_capture_latency (0)
72 , _plugin_signal_latency (0)
73 , _signal_analysis_collected_nframes(0)
74 , _signal_analysis_collect_nframes_max(0)
79 , _maps_from_state (false)
80 , _bypass_port (UINT32_MAX)
82 /* the first is the master */
86 create_automatable_parameters ();
87 const ChanCount& sc (sidechain_input_pins ());
88 if (sc.n_audio () > 0 || sc.n_midi () > 0) {
89 add_sidechain (sc.n_audio (), sc.n_midi ());
94 PluginInsert::~PluginInsert ()
99 PluginInsert::set_strict_io (bool b)
101 bool changed = _strict_io != b;
104 PluginConfigChanged (); /* EMIT SIGNAL */
109 PluginInsert::set_count (uint32_t num)
111 bool require_state = !_plugins.empty();
113 if (require_state && num > 1 && plugin (0)->get_info ()->type == ARDOUR::AudioUnit) {
114 // we don't allow to replicate AUs
118 /* this is a bad idea.... we shouldn't do this while active.
119 * only a route holding their redirect_lock should be calling this
124 } else if (num > _plugins.size()) {
125 uint32_t diff = num - _plugins.size();
127 for (uint32_t n = 0; n < diff; ++n) {
128 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
132 XMLNode& state = _plugins[0]->get_state ();
133 p->set_state (state, Stateful::loading_state_version);
140 PluginConfigChanged (); /* EMIT SIGNAL */
142 } else if (num < _plugins.size()) {
143 uint32_t diff = _plugins.size() - num;
144 for (uint32_t n= 0; n < diff; ++n) {
147 PluginConfigChanged (); /* EMIT SIGNAL */
155 PluginInsert::set_sinks (const ChanCount& c)
158 /* no signal, change will only be visible after re-config */
162 PluginInsert::set_outputs (const ChanCount& c)
164 bool changed = (_custom_out != c) && _custom_cfg;
167 PluginConfigChanged (); /* EMIT SIGNAL */
172 PluginInsert::set_custom_cfg (bool b)
174 bool changed = _custom_cfg != b;
177 PluginConfigChanged (); /* EMIT SIGNAL */
182 PluginInsert::set_preset_out (const ChanCount& c)
184 bool changed = _preset_out != c;
186 if (changed && !_custom_cfg) {
187 PluginConfigChanged (); /* EMIT SIGNAL */
193 PluginInsert::add_sidechain (uint32_t n_audio, uint32_t n_midi)
195 // caller must hold process lock
199 std::ostringstream n;
200 if (n_audio > 0 || n_midi > 0) {
201 n << "Sidechain " << Session::next_name_id ();
203 n << "TO BE RESET FROM XML";
205 SideChain *sc = new SideChain (_session, n.str ());
206 _sidechain = boost::shared_ptr<SideChain> (sc);
207 _sidechain->activate ();
208 for (uint32_t n = 0; n < n_audio; ++n) {
209 _sidechain->input()->add_port ("", owner(), DataType::AUDIO); // add a port, don't connect.
211 for (uint32_t n = 0; n < n_midi; ++n) {
212 _sidechain->input()->add_port ("", owner(), DataType::MIDI); // add a port, don't connect.
214 PluginConfigChanged (); /* EMIT SIGNAL */
219 PluginInsert::del_sidechain ()
225 _sc_playback_latency = 0;
226 _sc_capture_latency = 0;
227 PluginConfigChanged (); /* EMIT SIGNAL */
232 PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback)
235 (_sc_playback_latency != playback || _sc_capture_latency != capture)) {
236 _sc_capture_latency = capture;
237 _sc_playback_latency = playback;
238 LatencyRange pl; pl.min = pl.max = playback;
239 LatencyRange cl; cl.min = cl.max = capture;
240 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback));
241 PortSet& ps (_sidechain->input ()->ports ());
242 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
243 p->set_private_latency_range (pl, true);
244 p->set_private_latency_range (cl, false);
250 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
252 if (which.type() != PluginAutomation)
255 boost::shared_ptr<AutomationControl> c
256 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
259 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
264 PluginInsert::output_streams() const
266 assert (_configured);
267 return _configured_out;
271 PluginInsert::input_streams() const
273 assert (_configured);
274 return _configured_in;
278 PluginInsert::internal_streams() const
280 assert (_configured);
281 return _configured_internal;
285 PluginInsert::internal_output_streams() const
287 assert (!_plugins.empty());
289 PluginInfoPtr info = _plugins.front()->get_info();
291 if (info->reconfigurable_io()) {
292 ChanCount out = _plugins.front()->output_streams ();
293 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
296 ChanCount out = info->n_outputs;
297 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
298 out.set_audio (out.n_audio() * _plugins.size());
299 out.set_midi (out.n_midi() * _plugins.size());
305 PluginInsert::internal_input_streams() const
307 assert (!_plugins.empty());
311 PluginInfoPtr info = _plugins.front()->get_info();
313 if (info->reconfigurable_io()) {
314 in = _plugins.front()->input_streams();
319 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
321 if (_match.method == Split) {
323 /* we are splitting 1 processor input to multiple plugin inputs,
324 so we have a maximum of 1 stream of each type.
326 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
327 if (in.get (*t) > 1) {
333 } else if (_match.method == Hide) {
335 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
336 in.set (*t, in.get (*t) - _match.hide.get (*t));
342 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
343 in.set (*t, in.get (*t) * _plugins.size ());
351 PluginInsert::natural_output_streams() const
354 if (is_channelstrip ()) {
355 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
358 return _plugins[0]->get_info()->n_outputs;
362 PluginInsert::natural_input_streams() const
365 if (is_channelstrip ()) {
366 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
369 return _plugins[0]->get_info()->n_inputs;
373 PluginInsert::sidechain_input_pins() const
375 return _cached_sidechain_pins;
379 PluginInsert::has_no_inputs() const
381 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
385 PluginInsert::has_no_audio_inputs() const
387 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
391 PluginInsert::plugin_latency () const {
392 return _plugins.front()->signal_latency ();
396 PluginInsert::needs_midi_input() const
398 PluginInfoPtr pip = _plugins[0]->get_info();
399 if (pip->needs_midi_input ()) {
402 return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
406 PluginInsert::has_output_presets (ChanCount in, ChanCount out)
408 if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) {
409 // collect possible configurations, prefer given in/out
410 _plugins[0]->can_support_io_configuration (in, out);
413 PluginOutputConfiguration ppc (_plugins[0]->possible_output ());
415 if (ppc.size () == 0) {
418 if (!strict_io () && ppc.size () == 1) {
422 if (strict_io () && ppc.size () == 1) {
423 // "stereo" is currently preferred default for instruments
424 if (ppc.find (2) != ppc.end ()) {
428 if (!needs_midi_input ()) {
435 PluginInsert::create_automatable_parameters ()
437 assert (!_plugins.empty());
439 boost::shared_ptr<Plugin> plugin = _plugins.front();
440 set<Evoral::Parameter> a = _plugins.front()->automatable ();
442 for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
443 if (!plugin->parameter_is_control (i) || !plugin->parameter_is_input (i)) {
446 Evoral::Parameter param (PluginAutomation, 0, i);
448 ParameterDescriptor desc;
449 plugin->get_parameter_descriptor(i, desc);
451 const bool automatable = a.find(param) != a.end();
454 can_automate (param);
456 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
457 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
459 c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
462 plugin->set_automation_control (i, c);
466 const Plugin::PropertyDescriptors& pdl (plugin->get_supported_properties ());
467 for (Plugin::PropertyDescriptors::const_iterator p = pdl.begin(); p != pdl.end(); ++p) {
468 Evoral::Parameter param (PluginPropertyAutomation, 0, p->first);
469 const ParameterDescriptor& desc = plugin->get_property_descriptor(param.id());
470 if (desc.datatype != Variant::NOTHING) {
471 boost::shared_ptr<AutomationList> list;
472 if (Variant::type_is_numeric(desc.datatype)) {
473 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
475 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
479 _bypass_port = plugin->designated_bypass_port ();
481 if (_bypass_port != UINT32_MAX) {
482 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
483 if (0 == (ac->flags () & Controllable::NotAutomatable)) {
484 ac->alist()->automation_state_changed.connect_same_thread (*this, boost::bind (&PluginInsert::bypassable_changed, this));
485 ac->Changed.connect_same_thread (*this, boost::bind (&PluginInsert::enable_changed, this));
489 /** Called when something outside of this host has modified a plugin
490 * parameter. Responsible for propagating the change to two places:
492 * 1) anything listening to the Control itself
493 * 2) any replicated plugins that make up this PluginInsert.
495 * The PluginInsert is connected to the ParameterChangedExternally signal for
496 * the first (primary) plugin, and here broadcasts that change to any others.
498 * XXX We should probably drop this whole replication idea (Paul, October 2015)
499 * since it isn't used by sensible plugin APIs (AU, LV2).
502 PluginInsert::parameter_changed_externally (uint32_t which, float val)
504 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
506 /* First propagation: alter the underlying value of the control,
507 * without telling the plugin(s) that own/use it to set it.
514 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
517 pc->catch_up_with_external_value (val);
520 /* Second propagation: tell all plugins except the first to
521 update the value of this parameter. For sane plugin APIs,
522 there are no other plugins, so this is a no-op in those
526 Plugins::iterator i = _plugins.begin();
528 /* don't set the first plugin, just all the slaves */
530 if (i != _plugins.end()) {
532 for (; i != _plugins.end(); ++i) {
533 (*i)->set_parameter (which, val);
539 PluginInsert::set_block_size (pframes_t nframes)
542 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
543 if ((*i)->set_block_size (nframes) != 0) {
551 PluginInsert::activate ()
553 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
557 Processor::activate ();
558 if (_plugin_signal_latency != signal_latency ()) {
559 _plugin_signal_latency = signal_latency ();
565 PluginInsert::deactivate ()
567 Processor::deactivate ();
569 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
572 if (_plugin_signal_latency != signal_latency ()) {
573 _plugin_signal_latency = signal_latency ();
579 PluginInsert::flush ()
581 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
587 PluginInsert::enable (bool yn)
589 if (_bypass_port == UINT32_MAX) {
596 if (!_pending_active) {
599 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
600 ac->set_value (yn ? 1.0 : 0.0, Controllable::NoGroup);
606 PluginInsert::enabled () const
608 if (_bypass_port == UINT32_MAX) {
609 return Processor::enabled ();
611 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
612 return (ac->get_value () > 0 && _pending_active);
617 PluginInsert::bypassable () const
619 if (_bypass_port == UINT32_MAX) {
622 boost::shared_ptr<const AutomationControl> ac = boost::const_pointer_cast<AutomationControl> (automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port)));
624 return !ac->automation_playback ();
629 PluginInsert::enable_changed ()
635 PluginInsert::bypassable_changed ()
637 BypassableChanged ();
641 PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const
643 // TODO optimize: store "unconnected" in a fixed set.
644 // it only changes on reconfiguration.
645 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
646 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
648 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
649 mapped = true; // in-place Midi bypass
651 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
652 PinMappings::const_iterator i = out_map.find (pc);
653 if (i == out_map.end ()) {
656 const ChanMapping& outmap (i->second);
657 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
659 uint32_t idx = outmap.get (*t, o, &valid);
660 if (valid && idx == out) {
667 bufs.get (*t, out).silence (nframes, offset);
674 PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes, framecnt_t offset, bool with_auto)
676 // TODO: atomically copy maps & _no_inplace
677 PinMappings in_map (_in_map);
678 PinMappings out_map (_out_map);
679 ChanMapping thru_map (_thru_map);
680 if (_mapping_changed) { // ToDo use a counters, increment until match.
681 _no_inplace = check_inplace ();
682 _mapping_changed = false;
685 if (_latency_changed) {
686 /* delaylines are configured with the max possible latency (as reported by the plugin)
687 * so this won't allocate memory (unless the plugin lied about its max latency)
688 * It may still 'click' though, since the fixed delaylines are not de-clicked.
689 * Then again plugin-latency changes are not click-free to begin with.
691 * This is also worst case, there is currently no concept of per-stream latency.
693 * e.g. Two identical latent plugins:
694 * 1st plugin: process left (latent), bypass right.
695 * 2nd plugin: bypass left, process right (latent).
696 * -> currently this yields 2 times latency of the plugin,
698 _latency_changed = false;
699 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
702 if (_match.method == Split && !_no_inplace) {
703 // TODO: also use this optimization if one source-buffer
704 // feeds _all_ *connected* inputs.
705 // currently this is *first* buffer to all only --
706 // see PluginInsert::check_inplace
707 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
708 if (_configured_internal.get (*t) == 0) {
712 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
713 assert (valid && first_idx == 0); // check_inplace ensures this
714 /* copy the first stream's buffer contents to the others */
715 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
716 uint32_t idx = in_map[0].get (*t, i, &valid);
719 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
723 /* the copy operation produces a linear monotonic input map */
724 in_map[0] = ChanMapping (natural_input_streams ());
727 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
728 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
734 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
736 boost::shared_ptr<AutomationControl> c
737 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
739 if (c->list() && c->automation_playback()) {
742 const float val = c->list()->rt_safe_eval (start, valid);
745 /* This is the ONLY place where we are
747 * AutomationControl::set_value_unchecked(). We
748 * know that the control is in
749 * automation playback mode, so no
750 * check on writable() is required
751 * (which must be done in AutomationControl::set_value()
754 c->set_value_unchecked(val);
761 /* Calculate if, and how many frames we need to collect for analysis */
762 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
763 _signal_analysis_collected_nframes);
764 if (nframes < collect_signal_nframes) { // we might not get all frames now
765 collect_signal_nframes = nframes;
768 if (collect_signal_nframes > 0) {
770 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
771 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
772 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
774 _signal_analysis_inputs.set_count(input_streams());
776 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
777 _signal_analysis_inputs.get_audio(i).read_from (
779 collect_signal_nframes,
780 _signal_analysis_collected_nframes); // offset is for target buffer
785 if (is_channelstrip ()) {
786 if (_configured_in.n_audio() > 0) {
787 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
788 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
790 _plugins.front()->connect_and_run (bufs, start, end, speed, mb_in_map, mb_out_map, nframes, offset);
792 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
793 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
799 // TODO optimize -- build maps once.
801 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
802 ARDOUR::ChanMapping used_outputs;
804 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
806 /* build used-output map */
807 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
808 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
809 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
811 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
813 used_outputs.set (*t, out_idx, 1); // mark as used
818 /* copy thru data to outputs before processing in-place */
819 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
820 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
822 uint32_t in_idx = thru_map.get (*t, out, &valid);
823 uint32_t m = out + natural_input_streams ().get (*t);
825 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
826 used_outputs.set (*t, out, 1); // mark as used
828 used_outputs.get (*t, out, &valid);
830 /* the plugin is expected to write here, but may not :(
831 * (e.g. drumgizmo w/o kit loaded)
833 inplace_bufs.get (*t, m).silence (nframes);
840 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
842 ARDOUR::ChanMapping i_in_map (natural_input_streams());
843 ARDOUR::ChanMapping i_out_map (out_map[pc]);
844 ARDOUR::ChanCount mapped;
846 /* map inputs sequentially */
847 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
848 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
850 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
851 uint32_t m = mapped.get (*t);
853 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
855 inplace_bufs.get (*t, m).silence (nframes, offset);
857 mapped.set (*t, m + 1);
861 /* outputs are mapped to inplace_bufs after the inputs */
862 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
863 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
866 if ((*i)->connect_and_run (inplace_bufs, start, end, speed, i_in_map, i_out_map, nframes, offset)) {
871 /* all instances have completed, now copy data that was written
872 * and zero unconnected buffers */
873 ARDOUR::ChanMapping nonzero_out (used_outputs);
874 if (has_midi_bypass ()) {
875 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
877 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
878 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
880 used_outputs.get (*t, out, &valid);
882 nonzero_out.get (*t, out, &valid);
884 bufs.get (*t, out).silence (nframes, offset);
887 uint32_t m = out + natural_input_streams ().get (*t);
888 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
893 /* in-place processing */
895 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
896 if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) {
900 // now silence unconnected outputs
901 inplace_silence_unconnected (bufs, _out_map, nframes, offset);
904 if (collect_signal_nframes > 0) {
906 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
907 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
909 _signal_analysis_outputs.set_count(output_streams());
911 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
912 _signal_analysis_outputs.get_audio(i).read_from(
914 collect_signal_nframes,
915 _signal_analysis_collected_nframes); // offset is for target buffer
918 _signal_analysis_collected_nframes += collect_signal_nframes;
919 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
921 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
922 _signal_analysis_collect_nframes_max = 0;
923 _signal_analysis_collected_nframes = 0;
925 AnalysisDataGathered(&_signal_analysis_inputs,
926 &_signal_analysis_outputs);
930 if (_plugin_signal_latency != signal_latency ()) {
931 _plugin_signal_latency = signal_latency ();
937 PluginInsert::bypass (BufferSet& bufs, pframes_t nframes)
939 /* bypass the plugin(s) not the whole processor.
940 * -> use mappings just like connect_and_run
943 // TODO: atomically copy maps & _no_inplace
944 const ChanMapping in_map (no_sc_input_map ());
945 const ChanMapping out_map (output_map ());
946 if (_mapping_changed) {
947 _no_inplace = check_inplace ();
948 _mapping_changed = false;
951 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
952 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
955 ChanMapping thru_map (_thru_map);
957 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
959 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
960 for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) {
961 inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0);
964 ARDOUR::ChanMapping used_outputs;
966 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
967 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
969 uint32_t in_idx = thru_map.get (*t, out, &valid);
971 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
972 used_outputs.set (*t, out, 1); // mark as used
976 // plugin no-op: assume every plugin has an internal identity map
977 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
978 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
980 uint32_t src_idx = out_map.get_src (*t, out, &valid);
984 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
988 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
989 used_outputs.set (*t, out, 1); // mark as used
992 // now silence all unused outputs
993 if (has_midi_bypass ()) {
994 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
996 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
997 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
999 used_outputs.get (*t, out, &valid);
1001 bufs.get (*t, out).silence (nframes, 0);
1006 if (_match.method == Split) {
1007 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1008 if (_configured_internal.get (*t) == 0) {
1011 // copy/feeds _all_ *connected* inputs, copy the first buffer
1013 uint32_t first_idx = in_map.get (*t, 0, &valid);
1014 assert (valid && first_idx == 0); // check_inplace ensures this
1015 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1016 uint32_t idx = in_map.get (*t, i, &valid);
1019 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0);
1025 // apply output map and/or monotonic but not identity i/o mappings
1026 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1027 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
1029 uint32_t src_idx = out_map.get_src (*t, out, &valid);
1031 bufs.get (*t, out).silence (nframes, 0);
1034 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
1036 bufs.get (*t, out).silence (nframes, 0);
1039 if (in_idx != src_idx) {
1040 bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0);
1048 PluginInsert::silence (framecnt_t nframes, framepos_t start_frame)
1054 _delaybuffers.flush ();
1056 ChanMapping in_map (natural_input_streams ());
1057 ChanMapping out_map (natural_output_streams ());
1058 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
1060 if (is_channelstrip ()) {
1061 if (_configured_in.n_audio() > 0) {
1062 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
1066 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1067 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
1072 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, double speed, pframes_t nframes, bool)
1075 // collect sidechain input for complete cycle (!)
1076 // TODO we need delaylines here for latency compensation
1077 _sidechain->run (bufs, start_frame, end_frame, speed, nframes, true);
1080 if (_pending_active) {
1081 /* run as normal if we are active or moving from inactive to active */
1083 if (_session.transport_rolling() || _session.bounce_processing()) {
1084 automation_run (bufs, start_frame, end_frame, speed, nframes);
1086 connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, false);
1090 bypass (bufs, nframes);
1091 _delaybuffers.flush ();
1094 _active = _pending_active;
1096 /* we have no idea whether the plugin generated silence or not, so mark
1097 * all buffers appropriately.
1102 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes)
1104 Evoral::ControlEvent next_event (0, 0.0f);
1105 framecnt_t offset = 0;
1107 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
1110 connect_and_run (bufs, start, end, speed, nframes, offset, false);
1114 if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1116 /* no events have a time within the relevant range */
1118 connect_and_run (bufs, start, end, speed, nframes, offset, true);
1124 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - start), (framecnt_t) nframes);
1126 connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed
1132 if (!find_next_event (start, end, next_event)) {
1137 /* cleanup anything that is left to do */
1140 connect_and_run (bufs, start, start + nframes, speed, nframes, offset, true);
1145 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1147 if (param.type() != PluginAutomation)
1150 if (_plugins.empty()) {
1151 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1153 abort(); /*NOTREACHED*/
1156 return _plugins[0]->default_value (param.id());
1161 PluginInsert::can_reset_all_parameters ()
1164 uint32_t params = 0;
1165 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1167 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1169 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1173 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1179 if (ac->automation_state() & Play) {
1184 return all && (params > 0);
1188 PluginInsert::reset_parameters_to_default ()
1192 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1194 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1196 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1200 const float dflt = _plugins[0]->default_value (cid);
1201 const float curr = _plugins[0]->get_parameter (cid);
1207 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1212 if (ac->automation_state() & Play) {
1217 ac->set_value (dflt, Controllable::NoGroup);
1222 boost::shared_ptr<Plugin>
1223 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1225 boost::shared_ptr<LadspaPlugin> lp;
1226 boost::shared_ptr<LuaProc> lua;
1228 boost::shared_ptr<LV2Plugin> lv2p;
1230 #ifdef WINDOWS_VST_SUPPORT
1231 boost::shared_ptr<WindowsVSTPlugin> vp;
1233 #ifdef LXVST_SUPPORT
1234 boost::shared_ptr<LXVSTPlugin> lxvp;
1236 #ifdef AUDIOUNIT_SUPPORT
1237 boost::shared_ptr<AUPlugin> ap;
1240 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1241 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1242 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1243 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1245 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1246 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1248 #ifdef WINDOWS_VST_SUPPORT
1249 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1250 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1252 #ifdef LXVST_SUPPORT
1253 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1254 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1256 #ifdef AUDIOUNIT_SUPPORT
1257 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1258 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1262 fatal << string_compose (_("programming error: %1"),
1263 X_("unknown plugin type in PluginInsert::plugin_factory"))
1265 abort(); /*NOTREACHED*/
1266 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1270 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1271 if (num < _in_map.size()) {
1272 bool changed = _in_map[num] != m;
1274 changed |= sanitize_maps ();
1276 PluginMapChanged (); /* EMIT SIGNAL */
1277 _mapping_changed = true;
1278 _session.set_dirty();
1284 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1285 if (num < _out_map.size()) {
1286 bool changed = _out_map[num] != m;
1288 changed |= sanitize_maps ();
1290 PluginMapChanged (); /* EMIT SIGNAL */
1291 _mapping_changed = true;
1292 _session.set_dirty();
1298 PluginInsert::set_thru_map (ChanMapping m) {
1299 bool changed = _thru_map != m;
1301 changed |= sanitize_maps ();
1303 PluginMapChanged (); /* EMIT SIGNAL */
1304 _mapping_changed = true;
1305 _session.set_dirty();
1310 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1311 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1313 if (_configured) { return false; }
1314 _configured_in = in;
1315 _configured_out = out;
1319 _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1324 PluginInsert::input_map () const
1328 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1329 ChanMapping m (i->second);
1330 const ChanMapping::Mappings& mp ((*i).second.mappings());
1331 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1332 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1333 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1342 PluginInsert::no_sc_input_map () const
1346 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1347 ChanMapping m (i->second);
1348 const ChanMapping::Mappings& mp ((*i).second.mappings());
1349 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1350 uint32_t ins = natural_input_streams().get(tm->first) - _cached_sidechain_pins.get(tm->first);
1351 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1352 if (i->first < ins) {
1353 rv.set (tm->first, i->first + pc * ins, i->second);
1362 PluginInsert::output_map () const
1366 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1367 ChanMapping m (i->second);
1368 const ChanMapping::Mappings& mp ((*i).second.mappings());
1369 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1370 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1371 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1375 if (has_midi_bypass ()) {
1376 rv.set (DataType::MIDI, 0, 0);
1383 PluginInsert::has_midi_bypass () const
1385 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1386 && natural_output_streams ().n_midi () == 0) {
1393 PluginInsert::has_midi_thru () const
1395 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1396 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1404 PluginInsert::is_channelstrip () const {
1405 return _plugins.front()->is_channelstrip();
1410 PluginInsert::check_inplace ()
1412 bool inplace_ok = !_plugins.front()->inplace_broken ();
1414 if (_thru_map.n_total () > 0) {
1415 // TODO once midi-bypass is part of the mapping, ignore it
1419 if (_match.method == Split && inplace_ok) {
1420 assert (get_count() == 1);
1421 assert (_in_map.size () == 1);
1422 if (!_out_map[0].is_monotonic ()) {
1425 if (_configured_internal != _configured_in) {
1426 /* no sidechain -- TODO we could allow this with
1427 * some more logic in PluginInsert::connect_and_run().
1429 * PluginInsert::reset_map() already maps it.
1434 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1435 if (_configured_internal.get (*t) == 0) {
1439 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1440 if (!valid || first_idx != 0) {
1441 // so far only allow to copy the *first* stream's buffer to others
1444 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1445 uint32_t idx = _in_map[0].get (*t, i, &valid);
1446 if (valid && idx != first_idx) {
1455 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1460 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1461 if (!_in_map[pc].is_monotonic ()) {
1464 if (!_out_map[pc].is_monotonic ()) {
1470 /* check if every output is fed by the corresponding input
1472 * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2
1473 * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1)
1475 * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
1477 ChanMapping in_map (input_map ());
1478 const ChanMapping::Mappings out_m (output_map ().mappings ());
1479 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1480 for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1481 /* src-pin: c->first, out-port: c->second */
1483 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1484 if (valid && in_port != c->second) {
1492 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1493 return !inplace_ok; // no-inplace
1497 PluginInsert::sanitize_maps ()
1499 bool changed = false;
1500 /* strip dead wood */
1501 PinMappings new_ins;
1502 PinMappings new_outs;
1503 ChanMapping new_thru;
1505 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1507 ChanMapping new_out;
1508 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1509 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1511 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1512 if (valid && idx < _configured_internal.get (*t)) {
1513 new_in.set (*t, i, idx);
1516 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1518 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1519 if (valid && idx < _configured_out.get (*t)) {
1520 new_out.set (*t, o, idx);
1524 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1527 new_ins[pc] = new_in;
1528 new_outs[pc] = new_out;
1531 /* prevent dup output assignments */
1532 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1533 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1534 bool mapped = false;
1535 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1537 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1538 if (valid && mapped) {
1539 new_outs[pc].unset (*t, idx);
1547 /* remove excess thru */
1548 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1549 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1551 uint32_t idx = _thru_map.get (*t, o, &valid);
1552 if (valid && idx < _configured_internal.get (*t)) {
1553 new_thru.set (*t, o, idx);
1558 /* prevent out + thru, existing plugin outputs override thru */
1559 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1560 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1561 bool mapped = false;
1563 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1564 new_outs[pc].get_src (*t, o, &mapped);
1565 if (mapped) { break; }
1567 if (!mapped) { continue; }
1568 uint32_t idx = new_thru.get (*t, o, &valid);
1570 new_thru.unset (*t, idx);
1575 if (has_midi_bypass ()) {
1576 // TODO: include midi-bypass in the thru set,
1577 // remove dedicated handling.
1578 new_thru.unset (DataType::MIDI, 0);
1581 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1585 _out_map = new_outs;
1586 _thru_map = new_thru;
1592 PluginInsert::reset_map (bool emit)
1594 const PinMappings old_in (_in_map);
1595 const PinMappings old_out (_out_map);
1599 _thru_map = ChanMapping ();
1601 /* build input map */
1602 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1603 uint32_t sc = 0; // side-chain round-robin (all instances)
1605 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1606 const uint32_t nis = natural_input_streams ().get(*t);
1607 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1609 /* SC inputs are last in the plugin-insert.. */
1610 const uint32_t sc_start = _configured_in.get (*t);
1611 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1612 /* ...but may not be at the end of the plugin ports.
1613 * in case the side-chain is not the last port, shift connections back.
1614 * and connect to side-chain
1617 uint32_t ic = 0; // split inputs
1618 const uint32_t cend = _configured_in.get (*t);
1620 for (uint32_t in = 0; in < nis; ++in) {
1621 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1622 if (iod.is_sidechain) {
1623 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1624 if (sc_len > 0) {// side-chain may be hidden
1625 _in_map[pc].set (*t, in, sc_start + sc);
1626 sc = (sc + 1) % sc_len;
1630 if (_match.method == Split) {
1631 if (cend == 0) { continue; }
1632 if (_strict_io && ic + stride * pc >= cend) {
1635 /* connect *no* sidechain sinks in round-robin fashion */
1636 _in_map[pc].set (*t, in, ic + stride * pc);
1637 if (_strict_io && (ic + 1) == cend) {
1640 ic = (ic + 1) % cend;
1642 uint32_t s = in - shift;
1643 if (stride * pc + s < cend) {
1644 _in_map[pc].set (*t, in, s + stride * pc);
1652 /* build output map */
1654 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1655 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1656 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1657 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1662 if (old_in == _in_map && old_out == _out_map) {
1666 PluginMapChanged (); /* EMIT SIGNAL */
1667 _mapping_changed = true;
1668 _session.set_dirty();
1674 PluginInsert::configure_io (ChanCount in, ChanCount out)
1676 Match old_match = _match;
1678 ChanCount old_internal;
1682 old_pins = natural_input_streams();
1683 old_in = _configured_in;
1684 old_out = _configured_out;
1685 old_internal = _configured_internal;
1687 _configured_in = in;
1688 _configured_internal = in;
1689 _configured_out = out;
1692 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1693 * (currently _sidechain->configure_io always succeeds
1694 * since Processor::configure_io() succeeds)
1696 if (!_sidechain->configure_io (in, out)) {
1697 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1700 _configured_internal += _sidechain->input()->n_ports();
1702 // include (static_cast<Route*>owner())->name() ??
1703 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1706 /* get plugin configuration */
1707 _match = private_can_support_io_configuration (in, out);
1709 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1711 DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
1712 DEBUG_STR_APPEND(a, _match);
1713 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1717 /* set the matching method and number of plugins that we will use to meet this configuration */
1718 if (set_count (_match.plugins) == false) {
1719 PluginIoReConfigure (); /* EMIT SIGNAL */
1720 _configured = false;
1724 /* configure plugins */
1725 switch (_match.method) {
1728 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1729 PluginIoReConfigure (); /* EMIT SIGNAL */
1730 _configured = false;
1736 ChanCount din (_configured_internal);
1737 ChanCount dout (din); // hint
1739 if (_custom_sinks.n_total () > 0) {
1740 din = _custom_sinks;
1743 } else if (_preset_out.n_audio () > 0) {
1744 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1745 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1746 dout.set (DataType::AUDIO, 2);
1748 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1750 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1751 bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1753 if (useins.n_audio() == 0) {
1756 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1758 if (_plugins.front()->configure_io (useins, dout) == false) {
1759 PluginIoReConfigure (); /* EMIT SIGNAL */
1760 _configured = false;
1764 _custom_sinks = din;
1769 if (_plugins.front()->configure_io (in, out) == false) {
1770 PluginIoReConfigure (); /* EMIT SIGNAL */
1771 _configured = false;
1777 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",
1779 _configured ? "Y" : "N",
1780 _maps_from_state ? "Y" : "N",
1781 old_in == in ? "==" : "!=",
1782 old_out == out ? "==" : "!=",
1783 old_pins == natural_input_streams () ? "==" : "!=",
1784 old_match.method == _match.method ? "==" : "!=",
1785 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1786 _in_map.size() == get_count () ? "==" : "!=",
1787 _out_map.size() == get_count () ? "==" : "!="
1790 bool mapping_changed = false;
1791 if (old_in == in && old_out == out
1793 && old_pins == natural_input_streams ()
1794 && old_match.method == _match.method
1795 && old_match.custom_cfg == _match.custom_cfg
1796 && _in_map.size() == _out_map.size()
1797 && _in_map.size() == get_count ()
1799 assert (_maps_from_state == false);
1800 /* If the configuration has not changed, keep the mapping */
1801 mapping_changed = sanitize_maps ();
1802 } else if (_match.custom_cfg && _configured) {
1803 assert (_maps_from_state == false);
1804 /* don't touch the map in manual mode */
1805 mapping_changed = sanitize_maps ();
1808 if (is_channelstrip ()) {
1809 /* fake channel map - for wire display */
1812 _thru_map = ChanMapping ();
1813 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1814 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1815 /* set "thru" map for in-place forward of audio */
1816 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1817 _thru_map.set (DataType::AUDIO, i, i);
1819 /* and midi (after implicit 1st channel bypass) */
1820 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1821 _thru_map.set (DataType::MIDI, i, i);
1825 if (_maps_from_state && old_in == in && old_out == out) {
1826 mapping_changed = true;
1829 /* generate a new mapping */
1830 mapping_changed = reset_map (false);
1832 _maps_from_state = false;
1835 if (mapping_changed) {
1836 PluginMapChanged (); /* EMIT SIGNAL */
1839 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1842 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1843 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1845 DEBUG_STR_APPEND(a, "----><----\n");
1847 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1848 DEBUG_STR_APPEND(a, " * Inputs:\n");
1849 DEBUG_STR_APPEND(a, _in_map[pc]);
1850 DEBUG_STR_APPEND(a, " * Outputs:\n");
1851 DEBUG_STR_APPEND(a, _out_map[pc]);
1853 DEBUG_STR_APPEND(a, " * Thru:\n");
1854 DEBUG_STR_APPEND(a, _thru_map);
1855 DEBUG_STR_APPEND(a, "-------->>--------\n");
1856 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1861 _no_inplace = check_inplace ();
1862 _mapping_changed = false;
1864 /* only the "noinplace_buffers" thread buffers need to be this large,
1865 * this can be optimized. other buffers are fine with
1866 * ChanCount::max (natural_input_streams (), natural_output_streams())
1867 * and route.cc's max (configured_in, configured_out)
1869 * no-inplace copies "thru" outputs (to emulate in-place) for
1870 * all outputs (to prevent overwrite) into a temporary space
1871 * which also holds input buffers (in case the plugin does process
1872 * in-place and overwrites those).
1874 * this buffers need to be at least as
1875 * natural_input_streams () + possible outputs.
1877 * sidechain inputs add a constraint on the input:
1878 * configured input + sidechain (=_configured_internal)
1880 * NB. this also satisfies
1881 * max (natural_input_streams(), natural_output_streams())
1882 * which is needed for silence runs
1884 _required_buffers = ChanCount::max (_configured_internal,
1885 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1887 if (old_in != in || old_out != out || old_internal != _configured_internal
1888 || old_pins != natural_input_streams ()
1889 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1891 PluginIoReConfigure (); /* EMIT SIGNAL */
1894 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1895 _latency_changed = true;
1897 // we don't know the analysis window size, so we must work with the
1898 // current buffer size here. each request for data fills in these
1899 // buffers and the analyser makes sure it gets enough data for the
1901 session().ensure_buffer_set (_signal_analysis_inputs, in);
1902 _signal_analysis_inputs.set_count (in);
1904 session().ensure_buffer_set (_signal_analysis_outputs, out);
1905 _signal_analysis_outputs.set_count (out);
1907 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1910 return Processor::configure_io (in, out);
1913 /** Decide whether this PluginInsert can support a given IO configuration.
1914 * To do this, we run through a set of possible solutions in rough order of
1917 * @param in Required input channel count.
1918 * @param out Filled in with the output channel count if we return true.
1919 * @return true if the given IO configuration can be supported.
1922 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1925 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1927 return private_can_support_io_configuration (in, out).method != Impossible;
1931 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1933 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1934 // preseed hint (for variable i/o)
1935 out.set (DataType::AUDIO, _preset_out.n_audio ());
1938 Match rv = internal_can_support_io_configuration (in, out);
1940 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1941 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
1942 out.set (DataType::AUDIO, _preset_out.n_audio ());
1947 /** A private version of can_support_io_configuration which returns the method
1948 * by which the configuration can be matched, rather than just whether or not
1952 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1954 if (_plugins.empty()) {
1959 if (is_channelstrip ()) {
1961 return Match (ExactMatch, 1);
1965 /* if a user specified a custom cfg, so be it. */
1967 PluginInfoPtr info = _plugins.front()->get_info();
1969 if (info->reconfigurable_io()) {
1970 return Match (Delegate, 1, _strict_io, true);
1972 return Match (ExactMatch, get_count(), _strict_io, true);
1976 /* try automatic configuration */
1977 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1979 PluginInfoPtr info = _plugins.front()->get_info();
1980 ChanCount inputs = info->n_inputs;
1981 ChanCount outputs = info->n_outputs;
1983 /* handle case strict-i/o */
1984 if (_strict_io && m.method != Impossible) {
1987 /* special case MIDI instruments */
1988 if (needs_midi_input ()) {
1989 // output = midi-bypass + at most master-out channels.
1990 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1991 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1992 out = ChanCount::min (out, max_out);
1993 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
1999 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
2000 /* replicate processor to match output count (generators and such)
2001 * at least enough to feed every output port. */
2002 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
2003 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2004 uint32_t nout = outputs.get (*t);
2005 if (nout == 0 || inx.get(*t) == 0) { continue; }
2006 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
2009 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
2010 return Match (Replicate, f, _strict_io);
2021 if (m.method != Impossible) {
2025 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2027 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
2029 if (info->reconfigurable_io()) {
2032 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2033 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2034 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
2036 // houston, we have a problem.
2037 return Match (Impossible, 0);
2040 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2041 return Match (Delegate, 1, _strict_io);
2044 ChanCount midi_bypass;
2045 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2046 midi_bypass.set (DataType::MIDI, 1);
2049 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
2051 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2052 uint32_t nin = ns_inputs.get (*t);
2053 uint32_t nout = outputs.get (*t);
2054 if (nin == 0 || inx.get(*t) == 0) { continue; }
2055 // prefer floor() so the count won't overly increase IFF (nin < nout)
2056 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
2058 if (f > 0 && outputs * f >= _configured_out) {
2059 out = outputs * f + midi_bypass;
2060 return Match (Replicate, f, _strict_io);
2063 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
2065 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2066 uint32_t nin = ns_inputs.get (*t);
2067 if (nin == 0 || inx.get(*t) == 0) { continue; }
2068 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2071 out = outputs * f + midi_bypass;
2072 return Match (Replicate, f, _strict_io);
2075 // add at least as many plugins needed to connect all inputs
2077 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2078 uint32_t nin = inputs.get (*t);
2079 if (nin == 0 || inx.get(*t) == 0) { continue; }
2080 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
2082 out = outputs * f + midi_bypass;
2083 return Match (Replicate, f, _strict_io);
2086 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
2088 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
2090 if (_plugins.empty()) {
2094 PluginInfoPtr info = _plugins.front()->get_info();
2095 ChanCount in; in += inx;
2096 ChanCount midi_bypass;
2098 if (info->reconfigurable_io()) {
2099 /* Plugin has flexible I/O, so delegate to it
2100 * pre-seed outputs, plugin tries closest match
2103 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
2104 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
2105 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
2107 return Match (Impossible, 0);
2110 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
2111 return Match (Delegate, 1);
2114 ChanCount inputs = info->n_inputs;
2115 ChanCount outputs = info->n_outputs;
2116 ChanCount ns_inputs = inputs - sidechain_input_pins ();
2118 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
2119 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
2120 midi_bypass.set (DataType::MIDI, 1);
2122 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
2123 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
2124 in.set(DataType::MIDI, 0);
2127 // add internally provided sidechain ports
2128 ChanCount insc = in + sidechain_input_ports ();
2130 bool no_inputs = true;
2131 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2132 if (inputs.get (*t) != 0) {
2139 /* no inputs so we can take any input configuration since we throw it away */
2140 out = outputs + midi_bypass;
2141 return Match (NoInputs, 1);
2144 /* Plugin inputs match requested inputs + side-chain-ports exactly */
2145 if (inputs == insc) {
2146 out = outputs + midi_bypass;
2147 return Match (ExactMatch, 1);
2150 /* Plugin inputs matches without side-chain-pins */
2151 if (ns_inputs == in) {
2152 out = outputs + midi_bypass;
2153 return Match (ExactMatch, 1);
2156 /* We may be able to run more than one copy of the plugin within this insert
2157 to cope with the insert having more inputs than the plugin.
2158 We allow replication only for plugins with either zero or 1 inputs and outputs
2159 for every valid data type.
2163 bool can_replicate = true;
2164 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2166 // ignore side-chains
2167 uint32_t nin = ns_inputs.get (*t);
2169 // No inputs of this type
2170 if (nin == 0 && in.get(*t) == 0) {
2174 if (nin != 1 || outputs.get (*t) != 1) {
2175 can_replicate = false;
2179 // Potential factor not set yet
2181 f = in.get(*t) / nin;
2184 // Factor for this type does not match another type, can not replicate
2185 if (f != (in.get(*t) / nin)) {
2186 can_replicate = false;
2191 if (can_replicate && f > 0) {
2192 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2193 out.set (*t, outputs.get(*t) * f);
2196 return Match (Replicate, f);
2199 /* If the processor has exactly one input of a given type, and
2200 the plugin has more, we can feed the single processor input
2201 to some or all of the plugin inputs. This is rather
2202 special-case-y, but the 1-to-many case is by far the
2203 simplest. How do I split thy 2 processor inputs to 3
2204 plugin inputs? Let me count the ways ...
2207 bool can_split = true;
2208 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2210 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2211 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2213 if (!can_split_type && !nothing_to_do_for_type) {
2219 out = outputs + midi_bypass;
2220 return Match (Split, 1);
2223 /* If the plugin has more inputs than we want, we can `hide' some of them
2224 by feeding them silence.
2227 bool could_hide = false;
2228 bool cannot_hide = false;
2229 ChanCount hide_channels;
2231 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2232 if (inputs.get(*t) > in.get(*t)) {
2233 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2234 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2236 } else if (inputs.get(*t) < in.get(*t)) {
2237 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2242 if (could_hide && !cannot_hide) {
2243 out = outputs + midi_bypass;
2244 return Match (Hide, 1, false, false, hide_channels);
2247 return Match (Impossible, 0);
2252 PluginInsert::get_state ()
2254 return state (true);
2258 PluginInsert::state (bool full)
2260 XMLNode& node = Processor::state (full);
2262 node.add_property("type", _plugins[0]->state_node_name());
2263 node.add_property("unique-id", _plugins[0]->unique_id());
2264 node.add_property("count", string_compose("%1", _plugins.size()));
2266 /* remember actual i/o configuration (for later placeholder
2267 * in case the plugin goes missing) */
2268 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2269 node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2270 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2271 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2273 /* save custom i/o config */
2274 node.add_property("custom", _custom_cfg ? "yes" : "no");
2275 for (uint32_t pc = 0; pc < get_count(); ++pc) {
2277 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2278 node.add_child_nocopy (* _in_map[pc].state (tmp));
2279 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2280 node.add_child_nocopy (* _out_map[pc].state (tmp));
2282 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2285 node.add_child_nocopy (_sidechain->state (full));
2288 _plugins[0]->set_insert_id(this->id());
2289 node.add_child_nocopy (_plugins[0]->get_state());
2291 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2292 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2294 node.add_child_nocopy (ac->get_state());
2302 PluginInsert::set_control_ids (const XMLNode& node, int version)
2304 const XMLNodeList& nlist = node.children();
2305 XMLNodeConstIterator iter;
2306 set<Evoral::Parameter>::const_iterator p;
2308 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2309 if ((*iter)->name() == Controllable::xml_node_name) {
2310 XMLProperty const * prop;
2312 uint32_t p = (uint32_t)-1;
2314 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
2315 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2317 p = lv2plugin->port_index(prop->value().c_str());
2321 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
2322 p = atoi (prop->value());
2325 if (p != (uint32_t)-1) {
2327 /* this may create the new controllable */
2329 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2331 #ifndef NO_PLUGIN_STATE
2335 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2337 ac->set_state (**iter, version);
2346 PluginInsert::set_state(const XMLNode& node, int version)
2348 XMLNodeList nlist = node.children();
2349 XMLNodeIterator niter;
2350 XMLPropertyList plist;
2351 XMLProperty const * prop;
2352 ARDOUR::PluginType type;
2354 if ((prop = node.property ("type")) == 0) {
2355 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2359 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2360 type = ARDOUR::LADSPA;
2361 } else if (prop->value() == X_("lv2")) {
2363 } else if (prop->value() == X_("windows-vst")) {
2364 type = ARDOUR::Windows_VST;
2365 } else if (prop->value() == X_("lxvst")) {
2366 type = ARDOUR::LXVST;
2367 } else if (prop->value() == X_("audiounit")) {
2368 type = ARDOUR::AudioUnit;
2369 } else if (prop->value() == X_("luaproc")) {
2372 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2378 prop = node.property ("unique-id");
2381 #ifdef WINDOWS_VST_SUPPORT
2382 /* older sessions contain VST plugins with only an "id" field.
2385 if (type == ARDOUR::Windows_VST) {
2386 prop = node.property ("id");
2390 #ifdef LXVST_SUPPORT
2391 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2393 if (type == ARDOUR::LXVST) {
2394 prop = node.property ("id");
2400 error << _("Plugin has no unique ID field") << endmsg;
2405 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2407 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2408 * allow to move sessions windows <> linux */
2409 #ifdef LXVST_SUPPORT
2410 if (plugin == 0 && type == ARDOUR::Windows_VST) {
2411 type = ARDOUR::LXVST;
2412 plugin = find_plugin (_session, prop->value(), type);
2416 #ifdef WINDOWS_VST_SUPPORT
2417 if (plugin == 0 && type == ARDOUR::LXVST) {
2418 type = ARDOUR::Windows_VST;
2419 plugin = find_plugin (_session, prop->value(), type);
2423 if (plugin == 0 && type == ARDOUR::Lua) {
2424 /* unique ID (sha1 of script) was not found,
2425 * load the plugin from the serialized version in the
2426 * session-file instead.
2428 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2429 XMLNode *ls = node.child (lp->state_node_name().c_str());
2431 lp->set_script_from_state (*ls);
2437 error << string_compose(
2438 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2439 "Perhaps it was removed or moved since it was last used."),
2445 // The name of the PluginInsert comes from the plugin, nothing else
2446 _name = plugin->get_info()->name;
2450 // Processor::set_state() will set this, but too late
2451 // for it to be available when setting up plugin
2452 // state. We can't call Processor::set_state() until
2453 // the plugins themselves are created and added.
2457 if (_plugins.empty()) {
2458 /* if we are adding the first plugin, we will need to set
2459 up automatable controls.
2461 add_plugin (plugin);
2462 create_automatable_parameters ();
2463 set_control_ids (node, version);
2466 if ((prop = node.property ("count")) != 0) {
2467 sscanf (prop->value().c_str(), "%u", &count);
2470 if (_plugins.size() != count) {
2471 for (uint32_t n = 1; n < count; ++n) {
2472 add_plugin (plugin_factory (plugin));
2476 Processor::set_state (node, version);
2478 PBD::ID new_id = this->id();
2479 PBD::ID old_id = this->id();
2481 if ((prop = node.property ("id")) != 0) {
2482 old_id = prop->value ();
2485 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2487 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2488 and set all plugins to the same state.
2491 if ((*niter)->name() == plugin->state_node_name()) {
2493 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2494 /* Plugin state can include external files which are named after the ID.
2496 * If regenerate_xml_or_string_ids() is set, the ID will already have
2497 * been changed, so we need to use the old ID from the XML to load the
2498 * state and then update the ID.
2500 * When copying a plugin-state, route_ui takes care of of updating the ID,
2501 * but we need to call set_insert_id() to clear the cached plugin-state
2502 * and force a change.
2504 if (!regenerate_xml_or_string_ids ()) {
2505 (*i)->set_insert_id (new_id);
2507 (*i)->set_insert_id (old_id);
2510 (*i)->set_state (**niter, version);
2512 if (regenerate_xml_or_string_ids ()) {
2513 (*i)->set_insert_id (new_id);
2521 if (version < 3000) {
2523 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2524 this is all handled by Automatable
2527 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2528 if ((*niter)->name() == "Redirect") {
2529 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2530 Processor::set_state (**niter, version);
2535 set_parameter_state_2X (node, version);
2538 if ((prop = node.property (X_("custom"))) != 0) {
2539 _custom_cfg = string_is_affirmative (prop->value());
2542 uint32_t in_maps = 0;
2543 uint32_t out_maps = 0;
2544 XMLNodeList kids = node.children ();
2545 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2546 if ((*i)->name() == X_("ConfiguredInput")) {
2547 _configured_in = ChanCount(**i);
2549 if ((*i)->name() == X_("CustomSinks")) {
2550 _custom_sinks = ChanCount(**i);
2552 if ((*i)->name() == X_("ConfiguredOutput")) {
2553 _custom_out = ChanCount(**i);
2554 _configured_out = ChanCount(**i);
2556 if ((*i)->name() == X_("PresetOutput")) {
2557 _preset_out = ChanCount(**i);
2559 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2560 long pc = atol (&((*i)->name().c_str()[9]));
2561 if (pc >= 0 && pc <= (long) get_count()) {
2562 _in_map[pc] = ChanMapping (**i);
2566 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2567 long pc = atol (&((*i)->name().c_str()[10]));
2568 if (pc >= 0 && pc <= (long) get_count()) {
2569 _out_map[pc] = ChanMapping (**i);
2573 if ((*i)->name () == "ThruMap") {
2574 _thru_map = ChanMapping (**i);
2577 // sidechain is a Processor (IO)
2578 if ((*i)->name () == Processor::state_node_name) {
2582 _sidechain->set_state (**i, version);
2586 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2587 _maps_from_state = true;
2590 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2594 (*i)->deactivate ();
2598 PluginConfigChanged (); /* EMIT SIGNAL */
2603 PluginInsert::update_id (PBD::ID id)
2606 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2607 (*i)->set_insert_id (id);
2612 PluginInsert::set_state_dir (const std::string& d)
2614 // state() only saves the state of the first plugin
2615 _plugins[0]->set_state_dir (d);
2619 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2621 XMLNodeList nlist = node.children();
2622 XMLNodeIterator niter;
2624 /* look for port automation node */
2626 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2628 if ((*niter)->name() != port_automation_node_name) {
2633 XMLProperty const * cprop;
2634 XMLNodeConstIterator iter;
2639 cnodes = (*niter)->children ("port");
2641 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2645 if ((cprop = child->property("number")) != 0) {
2646 port = cprop->value().c_str();
2648 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2652 sscanf (port, "%" PRIu32, &port_id);
2654 if (port_id >= _plugins[0]->parameter_count()) {
2655 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2659 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2660 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2662 if (c && c->alist()) {
2663 if (!child->children().empty()) {
2664 c->alist()->set_state (*child->children().front(), version);
2666 /* In some cases 2.X saves lists with min_yval and max_yval
2667 being FLT_MIN and FLT_MAX respectively. This causes problems
2668 in A3 because these min/max values are used to compute
2669 where GUI control points should be drawn. If we see such
2670 values, `correct' them to the min/max of the appropriate
2674 float min_y = c->alist()->get_min_y ();
2675 float max_y = c->alist()->get_max_y ();
2677 ParameterDescriptor desc;
2678 _plugins.front()->get_parameter_descriptor (port_id, desc);
2680 if (min_y == FLT_MIN) {
2684 if (max_y == FLT_MAX) {
2688 c->alist()->set_yrange (min_y, max_y);
2691 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2703 PluginInsert::describe_parameter (Evoral::Parameter param)
2705 if (param.type() == PluginAutomation) {
2706 return _plugins[0]->describe_parameter (param);
2707 } else if (param.type() == PluginPropertyAutomation) {
2708 boost::shared_ptr<AutomationControl> c(automation_control(param));
2709 if (c && !c->desc().label.empty()) {
2710 return c->desc().label;
2713 return Automatable::describe_parameter(param);
2717 PluginInsert::signal_latency() const
2719 if (!_pending_active) {
2722 if (_user_latency) {
2723 return _user_latency;
2726 return _plugins[0]->signal_latency ();
2730 PluginInsert::type ()
2732 return plugin()->get_info()->type;
2735 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2736 const Evoral::Parameter& param,
2737 const ParameterDescriptor& desc,
2738 boost::shared_ptr<AutomationList> list)
2739 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2743 alist()->reset_default (desc.normal);
2745 list->set_interpolation(Evoral::ControlList::Discrete);
2750 /** @param val `user' value */
2753 PluginInsert::PluginControl::actually_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2755 /* FIXME: probably should be taking out some lock here.. */
2757 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2758 (*i)->set_parameter (_list->parameter().id(), user_val);
2761 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2763 iasp->set_parameter (_list->parameter().id(), user_val);
2766 AutomationControl::actually_set_value (user_val, group_override);
2770 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2772 AutomationControl::actually_set_value (user_val, Controllable::NoGroup);
2776 PluginInsert::PluginControl::get_state ()
2780 XMLNode& node (AutomationControl::get_state());
2781 ss << parameter().id();
2782 node.add_property (X_("parameter"), ss.str());
2784 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2786 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2793 /** @return `user' val */
2795 PluginInsert::PluginControl::get_value () const
2797 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2803 return plugin->get_parameter (_list->parameter().id());
2806 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2807 const Evoral::Parameter& param,
2808 const ParameterDescriptor& desc,
2809 boost::shared_ptr<AutomationList> list)
2810 : AutomationControl (p->session(), param, desc, list)
2814 alist()->set_yrange (desc.lower, desc.upper);
2815 alist()->reset_default (desc.normal);
2820 PluginInsert::PluginPropertyControl::actually_set_value (double user_val, Controllable::GroupControlDisposition gcd)
2822 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2823 This is lossy, but better than nothing until Ardour's automation system
2824 can handle various datatypes all the way down. */
2825 const Variant value(_desc.datatype, user_val);
2826 if (value.type() == Variant::NOTHING) {
2827 error << "set_value(double) called for non-numeric property" << endmsg;
2831 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2832 (*i)->set_property(_list->parameter().id(), value);
2837 AutomationControl::actually_set_value (user_val, gcd);
2841 PluginInsert::PluginPropertyControl::get_state ()
2845 XMLNode& node (AutomationControl::get_state());
2846 ss << parameter().id();
2847 node.add_property (X_("property"), ss.str());
2848 node.remove_property (X_("value"));
2854 PluginInsert::PluginPropertyControl::get_value () const
2856 return _value.to_double();
2859 boost::shared_ptr<Plugin>
2860 PluginInsert::get_impulse_analysis_plugin()
2862 boost::shared_ptr<Plugin> ret;
2863 if (_impulseAnalysisPlugin.expired()) {
2864 // LV2 in particular uses various _session params
2865 // during init() -- most notably block_size..
2867 ret = plugin_factory(_plugins[0]);
2868 ChanCount out (internal_output_streams ());
2869 if (ret->get_info ()->reconfigurable_io ()) {
2870 // populate get_info ()->n_inputs and ->n_outputs
2872 ret->can_support_io_configuration (internal_input_streams (), out, &useins);
2873 assert (out == internal_output_streams ());
2875 ret->configure_io (internal_input_streams (), out);
2876 _impulseAnalysisPlugin = ret;
2878 ret = _impulseAnalysisPlugin.lock();
2885 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2887 // called from outside the audio thread, so this should be safe
2888 // only do audio as analysis is (currently) only for audio plugins
2889 _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes);
2890 _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
2892 _signal_analysis_collected_nframes = 0;
2893 _signal_analysis_collect_nframes_max = nframes;
2896 /** Add a plugin to our list */
2898 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2900 plugin->set_insert_id (this->id());
2902 if (_plugins.empty()) {
2903 /* first (and probably only) plugin instance - connect to relevant signals */
2905 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2906 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2907 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2908 _custom_sinks = plugin->get_info()->n_inputs;
2909 // cache sidechain port count
2910 _cached_sidechain_pins.reset ();
2911 const ChanCount& nis (plugin->get_info()->n_inputs);
2912 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2913 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2914 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2915 if (iod.is_sidechain) {
2916 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2921 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2922 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2924 vst->set_insert (this, _plugins.size ());
2928 _plugins.push_back (plugin);
2932 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
2935 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2936 if (! (*i)->load_preset (pr)) {
2944 PluginInsert::realtime_handle_transport_stopped ()
2946 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2947 (*i)->realtime_handle_transport_stopped ();
2952 PluginInsert::realtime_locate ()
2954 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2955 (*i)->realtime_locate ();
2960 PluginInsert::monitoring_changed ()
2962 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2963 (*i)->monitoring_changed ();
2968 PluginInsert::latency_changed ()
2970 // this is called in RT context, LatencyChanged is emitted after run()
2971 _latency_changed = true;
2972 // XXX This also needs a proper API not an owner() hack.
2974 static_cast<Route*>(owner ())->processor_latency_changed (); /* EMIT SIGNAL */
2978 PluginInsert::start_touch (uint32_t param_id)
2980 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2982 ac->start_touch (session().audible_frame());
2987 PluginInsert::end_touch (uint32_t param_id)
2989 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2991 ac->stop_touch (true, session().audible_frame());
2995 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2998 case PluginInsert::Impossible: o << "Impossible"; break;
2999 case PluginInsert::Delegate: o << "Delegate"; break;
3000 case PluginInsert::NoInputs: o << "NoInputs"; break;
3001 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
3002 case PluginInsert::Replicate: o << "Replicate"; break;
3003 case PluginInsert::Split: o << "Split"; break;
3004 case PluginInsert::Hide: o << "Hide"; break;
3006 o << " cnt: " << m.plugins
3007 << (m.strict_io ? " strict-io" : "")
3008 << (m.custom_cfg ? " custom-cfg" : "");
3009 if (m.method == PluginInsert::Hide) {
3010 o << " hide: " << m.hide;