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 , _signal_analysis_collected_nframes(0)
71 , _signal_analysis_collect_nframes_max(0)
76 , _maps_from_state (false)
78 /* the first is the master */
82 create_automatable_parameters ();
83 const ChanCount& sc (sidechain_input_pins ());
84 if (sc.n_audio () > 0) {
85 add_sidechain (sc.n_audio ());
90 PluginInsert::~PluginInsert ()
95 PluginInsert::set_strict_io (bool b)
97 bool changed = _strict_io != b;
100 PluginConfigChanged (); /* EMIT SIGNAL */
105 PluginInsert::set_count (uint32_t num)
107 bool require_state = !_plugins.empty();
109 if (require_state && num > 1 && plugin (0)->get_info ()->type == ARDOUR::AudioUnit) {
110 // we don't allow to replicate AUs
114 /* this is a bad idea.... we shouldn't do this while active.
115 * only a route holding their redirect_lock should be calling this
120 } else if (num > _plugins.size()) {
121 uint32_t diff = num - _plugins.size();
123 for (uint32_t n = 0; n < diff; ++n) {
124 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
128 XMLNode& state = _plugins[0]->get_state ();
129 p->set_state (state, Stateful::loading_state_version);
136 PluginConfigChanged (); /* EMIT SIGNAL */
138 } else if (num < _plugins.size()) {
139 uint32_t diff = _plugins.size() - num;
140 for (uint32_t n= 0; n < diff; ++n) {
143 PluginConfigChanged (); /* EMIT SIGNAL */
151 PluginInsert::set_sinks (const ChanCount& c)
154 /* no signal, change will only be visible after re-config */
158 PluginInsert::set_outputs (const ChanCount& c)
160 bool changed = (_custom_out != c) && _custom_cfg;
163 PluginConfigChanged (); /* EMIT SIGNAL */
168 PluginInsert::set_custom_cfg (bool b)
170 bool changed = _custom_cfg != b;
173 PluginConfigChanged (); /* EMIT SIGNAL */
178 PluginInsert::set_preset_out (const ChanCount& c)
180 bool changed = _preset_out != c;
182 if (changed && !_custom_cfg) {
183 PluginConfigChanged (); /* EMIT SIGNAL */
189 PluginInsert::add_sidechain (uint32_t n_audio)
191 // caller must hold process lock
195 std::ostringstream n;
197 n << "Sidechain " << Session::next_name_id ();
199 n << "TO BE RESET FROM XML";
201 SideChain *sc = new SideChain (_session, n.str ());
202 _sidechain = boost::shared_ptr<SideChain> (sc);
203 _sidechain->activate ();
204 for (uint32_t n = 0; n < n_audio; ++n) {
205 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
207 PluginConfigChanged (); /* EMIT SIGNAL */
212 PluginInsert::del_sidechain ()
218 PluginConfigChanged (); /* EMIT SIGNAL */
223 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
225 if (which.type() != PluginAutomation)
228 boost::shared_ptr<AutomationControl> c
229 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
232 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
237 PluginInsert::output_streams() const
239 assert (_configured);
240 return _configured_out;
244 PluginInsert::input_streams() const
246 assert (_configured);
247 return _configured_in;
251 PluginInsert::internal_streams() const
253 assert (_configured);
254 return _configured_internal;
258 PluginInsert::internal_output_streams() const
260 assert (!_plugins.empty());
262 PluginInfoPtr info = _plugins.front()->get_info();
264 if (info->reconfigurable_io()) {
265 ChanCount out = _plugins.front()->output_streams ();
266 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
269 ChanCount out = info->n_outputs;
270 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
271 out.set_audio (out.n_audio() * _plugins.size());
272 out.set_midi (out.n_midi() * _plugins.size());
278 PluginInsert::internal_input_streams() const
280 assert (!_plugins.empty());
284 PluginInfoPtr info = _plugins.front()->get_info();
286 if (info->reconfigurable_io()) {
287 in = _plugins.front()->input_streams();
292 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
294 if (_match.method == Split) {
296 /* we are splitting 1 processor input to multiple plugin inputs,
297 so we have a maximum of 1 stream of each type.
299 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
300 if (in.get (*t) > 1) {
306 } else if (_match.method == Hide) {
308 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
309 in.set (*t, in.get (*t) - _match.hide.get (*t));
315 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
316 in.set (*t, in.get (*t) * _plugins.size ());
324 PluginInsert::natural_output_streams() const
327 if (is_channelstrip ()) {
328 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
331 return _plugins[0]->get_info()->n_outputs;
335 PluginInsert::natural_input_streams() const
338 if (is_channelstrip ()) {
339 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
342 return _plugins[0]->get_info()->n_inputs;
346 PluginInsert::sidechain_input_pins() const
348 return _cached_sidechain_pins;
352 PluginInsert::has_no_inputs() const
354 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
358 PluginInsert::has_no_audio_inputs() const
360 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
364 PluginInsert::plugin_latency () const {
365 return _plugins.front()->signal_latency ();
369 PluginInsert::needs_midi_input() const
371 PluginInfoPtr pip = _plugins[0]->get_info();
372 if (pip->needs_midi_input ()) {
375 return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
379 PluginInsert::has_output_presets (ChanCount in, ChanCount out)
381 if (!_configured && _plugins[0]->get_info ()->reconfigurable_io ()) {
382 // collect possible configurations, prefer given in/out
383 _plugins[0]->can_support_io_configuration (in, out);
386 PluginOutputConfiguration ppc (_plugins[0]->possible_output ());
388 if (ppc.size () == 0) {
391 if (!strict_io () && ppc.size () == 1) {
395 if (strict_io () && ppc.size () == 1) {
396 // "stereo" is currently preferred default for instruments
397 if (ppc.find (2) != ppc.end ()) {
401 if (!needs_midi_input ()) {
408 PluginInsert::create_automatable_parameters ()
410 assert (!_plugins.empty());
412 set<Evoral::Parameter> a = _plugins.front()->automatable ();
414 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
415 if (i->type() == PluginAutomation) {
417 Evoral::Parameter param(*i);
419 ParameterDescriptor desc;
420 _plugins.front()->get_parameter_descriptor(i->id(), desc);
422 can_automate (param);
423 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
424 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
426 _plugins.front()->set_automation_control (i->id(), c);
427 } else if (i->type() == PluginPropertyAutomation) {
428 Evoral::Parameter param(*i);
429 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
430 if (desc.datatype != Variant::NOTHING) {
431 boost::shared_ptr<AutomationList> list;
432 if (Variant::type_is_numeric(desc.datatype)) {
433 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
435 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
440 /** Called when something outside of this host has modified a plugin
441 * parameter. Responsible for propagating the change to two places:
443 * 1) anything listening to the Control itself
444 * 2) any replicated plugins that make up this PluginInsert.
446 * The PluginInsert is connected to the ParameterChangedExternally signal for
447 * the first (primary) plugin, and here broadcasts that change to any others.
449 * XXX We should probably drop this whole replication idea (Paul, October 2015)
450 * since it isn't used by sensible plugin APIs (AU, LV2).
453 PluginInsert::parameter_changed_externally (uint32_t which, float val)
455 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
457 /* First propagation: alter the underlying value of the control,
458 * without telling the plugin(s) that own/use it to set it.
465 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
468 pc->catch_up_with_external_value (val);
471 /* Second propagation: tell all plugins except the first to
472 update the value of this parameter. For sane plugin APIs,
473 there are no other plugins, so this is a no-op in those
477 Plugins::iterator i = _plugins.begin();
479 /* don't set the first plugin, just all the slaves */
481 if (i != _plugins.end()) {
483 for (; i != _plugins.end(); ++i) {
484 (*i)->set_parameter (which, val);
490 PluginInsert::set_block_size (pframes_t nframes)
493 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
494 if ((*i)->set_block_size (nframes) != 0) {
502 PluginInsert::activate ()
504 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
508 Processor::activate ();
512 PluginInsert::deactivate ()
514 Processor::deactivate ();
516 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
522 PluginInsert::flush ()
524 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
530 PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const
532 // TODO optimize: store "unconnected" in a fixed set.
533 // it only changes on reconfiguration.
534 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
535 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
537 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
538 mapped = true; // in-place Midi bypass
540 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
541 PinMappings::const_iterator i = out_map.find (pc);
542 if (i == out_map.end ()) {
545 const ChanMapping& outmap (i->second);
546 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
548 uint32_t idx = outmap.get (*t, o, &valid);
549 if (valid && idx == out) {
556 bufs.get (*t, out).silence (nframes, offset);
563 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
565 // TODO: atomically copy maps & _no_inplace
566 PinMappings in_map (_in_map);
567 PinMappings out_map (_out_map);
568 ChanMapping thru_map (_thru_map);
569 if (_mapping_changed) { // ToDo use a counters, increment until match.
570 _no_inplace = check_inplace ();
571 _mapping_changed = false;
574 if (_latency_changed) {
575 /* delaylines are configured with the max possible latency (as reported by the plugin)
576 * so this won't allocate memory (unless the plugin lied about its max latency)
577 * It may still 'click' though, since the fixed delaylines are not de-clicked.
578 * Then again plugin-latency changes are not click-free to begin with.
580 * This is also worst case, there is currently no concept of per-stream latency.
582 * e.g. Two identical latent plugins:
583 * 1st plugin: process left (latent), bypass right.
584 * 2nd plugin: bypass left, process right (latent).
585 * -> currently this yields 2 times latency of the plugin,
587 _latency_changed = false;
588 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
591 if (_match.method == Split && !_no_inplace) {
592 // TODO: also use this optimization if one source-buffer
593 // feeds _all_ *connected* inputs.
594 // currently this is *first* buffer to all only --
595 // see PluginInsert::check_inplace
596 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
597 if (_configured_internal.get (*t) == 0) {
601 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
602 assert (valid && first_idx == 0); // check_inplace ensures this
603 /* copy the first stream's buffer contents to the others */
604 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
605 uint32_t idx = in_map[0].get (*t, i, &valid);
608 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
612 /* the copy operation produces a linear monotonic input map */
613 in_map[0] = ChanMapping (natural_input_streams ());
616 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
617 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
623 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
625 boost::shared_ptr<AutomationControl> c
626 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
628 if (c->list() && c->automation_playback()) {
631 const float val = c->list()->rt_safe_eval (now, valid);
634 /* This is the ONLY place where we are
636 * AutomationControl::set_value_unchecked(). We
637 * know that the control is in
638 * automation playback mode, so no
639 * check on writable() is required
640 * (which must be done in AutomationControl::set_value()
643 c->set_value_unchecked(val);
650 /* Calculate if, and how many frames we need to collect for analysis */
651 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
652 _signal_analysis_collected_nframes);
653 if (nframes < collect_signal_nframes) { // we might not get all frames now
654 collect_signal_nframes = nframes;
657 if (collect_signal_nframes > 0) {
659 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
660 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
661 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
663 _signal_analysis_inputs.set_count(input_streams());
665 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
666 _signal_analysis_inputs.get_audio(i).read_from (
668 collect_signal_nframes,
669 _signal_analysis_collected_nframes); // offset is for target buffer
674 if (is_channelstrip ()) {
675 if (_configured_in.n_audio() > 0) {
676 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
677 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
679 _plugins.front()->connect_and_run (bufs, mb_in_map, mb_out_map, nframes, offset);
681 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
682 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
688 // TODO optimize -- build maps once.
690 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
691 ARDOUR::ChanMapping used_outputs;
693 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
695 /* build used-output map */
696 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
697 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
698 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
700 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
702 used_outputs.set (*t, out_idx, 1); // mark as used
707 /* copy thru data to outputs before processing in-place */
708 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
709 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
711 uint32_t in_idx = thru_map.get (*t, out, &valid);
712 uint32_t m = out + natural_input_streams ().get (*t);
714 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
715 used_outputs.set (*t, out, 1); // mark as used
717 used_outputs.get (*t, out, &valid);
719 /* the plugin is expected to write here, but may not :(
720 * (e.g. drumgizmo w/o kit loaded)
722 inplace_bufs.get (*t, m).silence (nframes);
729 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
731 ARDOUR::ChanMapping i_in_map (natural_input_streams());
732 ARDOUR::ChanMapping i_out_map (out_map[pc]);
733 ARDOUR::ChanCount mapped;
735 /* map inputs sequentially */
736 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
737 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
739 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
740 uint32_t m = mapped.get (*t);
742 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
744 inplace_bufs.get (*t, m).silence (nframes, offset);
746 mapped.set (*t, m + 1);
750 /* outputs are mapped to inplace_bufs after the inputs */
751 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
752 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
755 if ((*i)->connect_and_run (inplace_bufs, i_in_map, i_out_map, nframes, offset)) {
760 /* all instances have completed, now copy data that was written
761 * and zero unconnected buffers */
762 ARDOUR::ChanMapping nonzero_out (used_outputs);
763 if (has_midi_bypass ()) {
764 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
766 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
767 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
769 used_outputs.get (*t, out, &valid);
771 nonzero_out.get (*t, out, &valid);
773 bufs.get (*t, out).silence (nframes, offset);
776 uint32_t m = out + natural_input_streams ().get (*t);
777 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
782 /* in-place processing */
784 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
785 if ((*i)->connect_and_run(bufs, in_map[pc], out_map[pc], nframes, offset)) {
789 // now silence unconnected outputs
790 inplace_silence_unconnected (bufs, _out_map, nframes, offset);
793 if (collect_signal_nframes > 0) {
795 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
796 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
798 _signal_analysis_outputs.set_count(output_streams());
800 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
801 _signal_analysis_outputs.get_audio(i).read_from(
803 collect_signal_nframes,
804 _signal_analysis_collected_nframes); // offset is for target buffer
807 _signal_analysis_collected_nframes += collect_signal_nframes;
808 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
810 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
811 _signal_analysis_collect_nframes_max = 0;
812 _signal_analysis_collected_nframes = 0;
814 AnalysisDataGathered(&_signal_analysis_inputs,
815 &_signal_analysis_outputs);
821 PluginInsert::bypass (BufferSet& bufs, pframes_t nframes)
823 /* bypass the plugin(s) not the whole processor.
824 * -> use mappings just like connect_and_run
827 // TODO: atomically copy maps & _no_inplace
828 ChanMapping in_map (input_map ());
829 ChanMapping out_map (output_map ());
830 if (_mapping_changed) {
831 _no_inplace = check_inplace ();
832 _mapping_changed = false;
835 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
836 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
839 ChanMapping thru_map (_thru_map);
841 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
843 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
844 for (uint32_t in = 0; in < _configured_internal.get (*t); ++in) {
845 inplace_bufs.get (*t, in).read_from (bufs.get (*t, in), nframes, 0, 0);
848 ARDOUR::ChanMapping used_outputs;
850 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
851 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
853 uint32_t in_idx = thru_map.get (*t, out, &valid);
855 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
856 used_outputs.set (*t, out, 1); // mark as used
860 // plugin no-op: assume every plugin has an internal identity map
861 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
862 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
864 uint32_t src_idx = out_map.get_src (*t, out, &valid);
868 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
872 bufs.get (*t, out).read_from (inplace_bufs.get (*t, in_idx), nframes, 0, 0);
873 used_outputs.set (*t, out, 1); // mark as used
876 // now silence all unused outputs
877 if (has_midi_bypass ()) {
878 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
880 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
881 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
883 used_outputs.get (*t, out, &valid);
885 bufs.get (*t, out).silence (nframes, 0);
890 if (_match.method == Split) {
891 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
892 if (_configured_internal.get (*t) == 0) {
895 // copy/feeds _all_ *connected* inputs, copy the first buffer
897 uint32_t first_idx = in_map.get (*t, 0, &valid);
898 assert (valid && first_idx == 0); // check_inplace ensures this
899 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
900 uint32_t idx = in_map.get (*t, i, &valid);
903 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, 0, 0);
909 // apply output map and/or monotonic but not identity i/o mappings
910 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
911 for (uint32_t out = 0; out < _configured_out.get (*t); ++out) {
913 uint32_t src_idx = out_map.get_src (*t, out, &valid);
915 bufs.get (*t, out).silence (nframes, 0);
918 uint32_t in_idx = in_map.get (*t, src_idx, &valid);
920 bufs.get (*t, out).silence (nframes, 0);
923 if (in_idx != src_idx) {
924 bufs.get (*t, out).read_from (bufs.get (*t, in_idx), nframes, 0, 0);
932 PluginInsert::silence (framecnt_t nframes)
938 _delaybuffers.flush ();
940 ChanMapping in_map (natural_input_streams ());
941 ChanMapping out_map (natural_output_streams ());
942 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
944 if (is_channelstrip ()) {
945 if (_configured_in.n_audio() > 0) {
946 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0);
950 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
951 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0);
956 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
958 if (_pending_active) {
959 /* run as normal if we are active or moving from inactive to active */
962 // collect sidechain input for complete cycle (!)
963 // TODO we need delaylines here for latency compensation
964 _sidechain->run (bufs, start_frame, end_frame, nframes, true);
967 if (_session.transport_rolling() || _session.bounce_processing()) {
968 automation_run (bufs, start_frame, nframes);
970 connect_and_run (bufs, nframes, 0, false);
974 bypass (bufs, nframes);
975 _delaybuffers.flush ();
978 _active = _pending_active;
980 /* we have no idea whether the plugin generated silence or not, so mark
981 * all buffers appropriately.
986 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
988 Evoral::ControlEvent next_event (0, 0.0f);
989 framepos_t now = start;
990 framepos_t end = now + nframes;
991 framecnt_t offset = 0;
993 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
996 connect_and_run (bufs, nframes, offset, false);
1000 if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
1002 /* no events have a time within the relevant range */
1004 connect_and_run (bufs, nframes, offset, true, now);
1010 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
1012 connect_and_run (bufs, cnt, offset, true, now);
1018 if (!find_next_event (now, end, next_event)) {
1023 /* cleanup anything that is left to do */
1026 connect_and_run (bufs, nframes, offset, true, now);
1031 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
1033 if (param.type() != PluginAutomation)
1036 if (_plugins.empty()) {
1037 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
1039 abort(); /*NOTREACHED*/
1042 return _plugins[0]->default_value (param.id());
1047 PluginInsert::can_reset_all_parameters ()
1050 uint32_t params = 0;
1051 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1053 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1055 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1059 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1065 if (ac->automation_state() & Play) {
1070 return all && (params > 0);
1074 PluginInsert::reset_parameters_to_default ()
1078 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
1080 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
1082 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
1086 const float dflt = _plugins[0]->default_value (cid);
1087 const float curr = _plugins[0]->get_parameter (cid);
1093 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
1098 if (ac->automation_state() & Play) {
1103 ac->set_value (dflt, Controllable::NoGroup);
1108 boost::shared_ptr<Plugin>
1109 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
1111 boost::shared_ptr<LadspaPlugin> lp;
1112 boost::shared_ptr<LuaProc> lua;
1114 boost::shared_ptr<LV2Plugin> lv2p;
1116 #ifdef WINDOWS_VST_SUPPORT
1117 boost::shared_ptr<WindowsVSTPlugin> vp;
1119 #ifdef LXVST_SUPPORT
1120 boost::shared_ptr<LXVSTPlugin> lxvp;
1122 #ifdef AUDIOUNIT_SUPPORT
1123 boost::shared_ptr<AUPlugin> ap;
1126 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
1127 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
1128 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
1129 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
1131 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
1132 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
1134 #ifdef WINDOWS_VST_SUPPORT
1135 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
1136 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
1138 #ifdef LXVST_SUPPORT
1139 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
1140 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
1142 #ifdef AUDIOUNIT_SUPPORT
1143 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1144 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1148 fatal << string_compose (_("programming error: %1"),
1149 X_("unknown plugin type in PluginInsert::plugin_factory"))
1151 abort(); /*NOTREACHED*/
1152 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1156 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1157 if (num < _in_map.size()) {
1158 bool changed = _in_map[num] != m;
1160 changed |= sanitize_maps ();
1162 PluginMapChanged (); /* EMIT SIGNAL */
1163 _mapping_changed = true;
1164 _session.set_dirty();
1170 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1171 if (num < _out_map.size()) {
1172 bool changed = _out_map[num] != m;
1174 changed |= sanitize_maps ();
1176 PluginMapChanged (); /* EMIT SIGNAL */
1177 _mapping_changed = true;
1178 _session.set_dirty();
1184 PluginInsert::set_thru_map (ChanMapping m) {
1185 bool changed = _thru_map != m;
1187 changed |= sanitize_maps ();
1189 PluginMapChanged (); /* EMIT SIGNAL */
1190 _mapping_changed = true;
1191 _session.set_dirty();
1196 PluginInsert::pre_seed (const ChanCount& in, const ChanCount& out,
1197 const ChanMapping& im, const ChanMapping& om, const ChanMapping& tm)
1199 if (_configured) { return false; }
1200 _configured_in = in;
1201 _configured_out = out;
1205 _maps_from_state = in.n_total () > 0 && out.n_total () > 0;
1210 PluginInsert::input_map () const
1214 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1215 ChanMapping m (i->second);
1216 const ChanMapping::Mappings& mp ((*i).second.mappings());
1217 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1218 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1219 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1227 PluginInsert::output_map () const
1231 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1232 ChanMapping m (i->second);
1233 const ChanMapping::Mappings& mp ((*i).second.mappings());
1234 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1235 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1236 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1240 if (has_midi_bypass ()) {
1241 rv.set (DataType::MIDI, 0, 0);
1248 PluginInsert::has_midi_bypass () const
1250 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1251 && natural_output_streams ().n_midi () == 0) {
1258 PluginInsert::has_midi_thru () const
1260 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1261 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1269 PluginInsert::is_channelstrip () const {
1270 return _plugins.front()->is_channelstrip();
1275 PluginInsert::check_inplace ()
1277 bool inplace_ok = !_plugins.front()->inplace_broken ();
1279 if (_thru_map.n_total () > 0) {
1280 // TODO once midi-bypass is part of the mapping, ignore it
1284 if (_match.method == Split && inplace_ok) {
1285 assert (get_count() == 1);
1286 assert (_in_map.size () == 1);
1287 if (!_out_map[0].is_monotonic ()) {
1290 if (_configured_internal != _configured_in) {
1291 /* no sidechain -- TODO we could allow this with
1292 * some more logic in PluginInsert::connect_and_run().
1294 * PluginInsert::reset_map() already maps it.
1299 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1300 if (_configured_internal.get (*t) == 0) {
1304 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1305 if (!valid || first_idx != 0) {
1306 // so far only allow to copy the *first* stream's buffer to others
1309 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1310 uint32_t idx = _in_map[0].get (*t, i, &valid);
1311 if (valid && idx != first_idx) {
1320 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1325 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1326 if (!_in_map[pc].is_monotonic ()) {
1329 if (!_out_map[pc].is_monotonic ()) {
1335 /* check if every output is fed by the corresponding input
1337 * this prevents in-port 1 -> sink-pin 2 || source-pin 1 -> out port 1, source-pin 2 -> out port 2
1338 * (with in-place, source-pin 1 -> out port 1 overwrites in-port 1)
1340 * but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
1342 ChanMapping in_map (input_map ());
1343 const ChanMapping::Mappings out_m (output_map ().mappings ());
1344 for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
1345 for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
1346 /* src-pin: c->first, out-port: c->second */
1348 uint32_t in_port = in_map.get (t->first, c->first, &valid);
1349 if (valid && in_port != c->second) {
1357 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1358 return !inplace_ok; // no-inplace
1362 PluginInsert::sanitize_maps ()
1364 bool changed = false;
1365 /* strip dead wood */
1366 PinMappings new_ins;
1367 PinMappings new_outs;
1368 ChanMapping new_thru;
1370 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1372 ChanMapping new_out;
1373 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1374 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1376 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1377 if (valid && idx < _configured_internal.get (*t)) {
1378 new_in.set (*t, i, idx);
1381 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1383 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1384 if (valid && idx < _configured_out.get (*t)) {
1385 new_out.set (*t, o, idx);
1389 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1392 new_ins[pc] = new_in;
1393 new_outs[pc] = new_out;
1396 /* prevent dup output assignments */
1397 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1398 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1399 bool mapped = false;
1400 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1402 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1403 if (valid && mapped) {
1404 new_outs[pc].unset (*t, idx);
1412 /* remove excess thru */
1413 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1414 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1416 uint32_t idx = _thru_map.get (*t, o, &valid);
1417 if (valid && idx < _configured_internal.get (*t)) {
1418 new_thru.set (*t, o, idx);
1423 /* prevent out + thru, existing plugin outputs override thru */
1424 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1425 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1426 bool mapped = false;
1428 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1429 new_outs[pc].get_src (*t, o, &mapped);
1430 if (mapped) { break; }
1432 if (!mapped) { continue; }
1433 uint32_t idx = new_thru.get (*t, o, &valid);
1435 new_thru.unset (*t, idx);
1440 if (has_midi_bypass ()) {
1441 // TODO: include midi-bypass in the thru set,
1442 // remove dedicated handling.
1443 new_thru.unset (DataType::MIDI, 0);
1446 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1450 _out_map = new_outs;
1451 _thru_map = new_thru;
1457 PluginInsert::reset_map (bool emit)
1459 const PinMappings old_in (_in_map);
1460 const PinMappings old_out (_out_map);
1464 _thru_map = ChanMapping ();
1466 /* build input map */
1467 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1468 uint32_t sc = 0; // side-chain round-robin (all instances)
1470 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1471 const uint32_t nis = natural_input_streams ().get(*t);
1472 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1474 /* SC inputs are last in the plugin-insert.. */
1475 const uint32_t sc_start = _configured_in.get (*t);
1476 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1477 /* ...but may not be at the end of the plugin ports.
1478 * in case the side-chain is not the last port, shift connections back.
1479 * and connect to side-chain
1482 uint32_t ic = 0; // split inputs
1483 const uint32_t cend = _configured_in.get (*t);
1485 for (uint32_t in = 0; in < nis; ++in) {
1486 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1487 if (iod.is_sidechain) {
1488 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1489 if (sc_len > 0) {// side-chain may be hidden
1490 _in_map[pc].set (*t, in, sc_start + sc);
1491 sc = (sc + 1) % sc_len;
1495 if (_match.method == Split) {
1496 if (cend == 0) { continue; }
1497 if (_strict_io && ic + stride * pc >= cend) {
1500 /* connect *no* sidechain sinks in round-robin fashion */
1501 _in_map[pc].set (*t, in, ic + stride * pc);
1502 if (_strict_io && (ic + 1) == cend) {
1505 ic = (ic + 1) % cend;
1507 uint32_t s = in - shift;
1508 if (stride * pc + s < cend) {
1509 _in_map[pc].set (*t, in, s + stride * pc);
1517 /* build output map */
1519 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1520 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1521 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1522 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1527 if (old_in == _in_map && old_out == _out_map) {
1531 PluginMapChanged (); /* EMIT SIGNAL */
1532 _mapping_changed = true;
1533 _session.set_dirty();
1539 PluginInsert::configure_io (ChanCount in, ChanCount out)
1541 Match old_match = _match;
1543 ChanCount old_internal;
1547 old_pins = natural_input_streams();
1548 old_in = _configured_in;
1549 old_out = _configured_out;
1550 old_internal = _configured_internal;
1552 _configured_in = in;
1553 _configured_internal = in;
1554 _configured_out = out;
1557 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1558 * (currently _sidechain->configure_io always succeeds
1559 * since Processor::configure_io() succeeds)
1561 if (!_sidechain->configure_io (in, out)) {
1562 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1565 _configured_internal += _sidechain->input()->n_ports();
1567 // include (static_cast<Route*>owner())->name() ??
1568 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1571 /* get plugin configuration */
1572 _match = private_can_support_io_configuration (in, out);
1574 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1576 DEBUG_STR_APPEND(a, string_compose ("%1: ", name()));
1577 DEBUG_STR_APPEND(a, _match);
1578 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1582 /* set the matching method and number of plugins that we will use to meet this configuration */
1583 if (set_count (_match.plugins) == false) {
1584 PluginIoReConfigure (); /* EMIT SIGNAL */
1585 _configured = false;
1589 /* configure plugins */
1590 switch (_match.method) {
1593 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1594 PluginIoReConfigure (); /* EMIT SIGNAL */
1595 _configured = false;
1601 ChanCount din (_configured_internal);
1602 ChanCount dout (din); // hint
1604 if (_custom_sinks.n_total () > 0) {
1605 din = _custom_sinks;
1608 } else if (_preset_out.n_audio () > 0) {
1609 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1610 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1611 dout.set (DataType::AUDIO, 2);
1613 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1615 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate lookup : %2 %3\n", name(), din, dout));
1616 bool const r = _plugins.front()->can_support_io_configuration (din, dout, &useins);
1618 if (useins.n_audio() == 0) {
1621 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: Delegate configuration: %2 %3\n", name(), useins, dout));
1623 if (_plugins.front()->configure_io (useins, dout) == false) {
1624 PluginIoReConfigure (); /* EMIT SIGNAL */
1625 _configured = false;
1629 _custom_sinks = din;
1634 if (_plugins.front()->configure_io (in, out) == false) {
1635 PluginIoReConfigure (); /* EMIT SIGNAL */
1636 _configured = false;
1642 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",
1644 _configured ? "Y" : "N",
1645 _maps_from_state ? "Y" : "N",
1646 old_in == in ? "==" : "!=",
1647 old_out == out ? "==" : "!=",
1648 old_pins == natural_input_streams () ? "==" : "!=",
1649 old_match.method == _match.method ? "==" : "!=",
1650 old_match.custom_cfg == _match.custom_cfg ? "==" : "!=",
1651 _in_map.size() == get_count () ? "==" : "!=",
1652 _out_map.size() == get_count () ? "==" : "!="
1655 bool mapping_changed = false;
1656 if (old_in == in && old_out == out
1658 && old_pins == natural_input_streams ()
1659 && old_match.method == _match.method
1660 && old_match.custom_cfg == _match.custom_cfg
1661 && _in_map.size() == _out_map.size()
1662 && _in_map.size() == get_count ()
1664 assert (_maps_from_state == false);
1665 /* If the configuration has not changed, keep the mapping */
1666 mapping_changed = sanitize_maps ();
1667 } else if (_match.custom_cfg && _configured) {
1668 assert (_maps_from_state == false);
1669 /* don't touch the map in manual mode */
1670 mapping_changed = sanitize_maps ();
1673 if (is_channelstrip ()) {
1674 /* fake channel map - for wire display */
1677 _thru_map = ChanMapping ();
1678 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1679 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1680 /* set "thru" map for in-place forward of audio */
1681 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1682 _thru_map.set (DataType::AUDIO, i, i);
1684 /* and midi (after implicit 1st channel bypass) */
1685 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1686 _thru_map.set (DataType::MIDI, i, i);
1690 if (_maps_from_state && old_in == in && old_out == out) {
1691 mapping_changed = true;
1694 /* generate a new mapping */
1695 mapping_changed = reset_map (false);
1697 _maps_from_state = false;
1700 if (mapping_changed) {
1701 PluginMapChanged (); /* EMIT SIGNAL */
1704 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1707 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1708 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1710 DEBUG_STR_APPEND(a, "----><----\n");
1712 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1713 DEBUG_STR_APPEND(a, " * Inputs:\n");
1714 DEBUG_STR_APPEND(a, _in_map[pc]);
1715 DEBUG_STR_APPEND(a, " * Outputs:\n");
1716 DEBUG_STR_APPEND(a, _out_map[pc]);
1718 DEBUG_STR_APPEND(a, " * Thru:\n");
1719 DEBUG_STR_APPEND(a, _thru_map);
1720 DEBUG_STR_APPEND(a, "-------->>--------\n");
1721 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1726 _no_inplace = check_inplace ();
1727 _mapping_changed = false;
1729 /* only the "noinplace_buffers" thread buffers need to be this large,
1730 * this can be optimized. other buffers are fine with
1731 * ChanCount::max (natural_input_streams (), natural_output_streams())
1732 * and route.cc's max (configured_in, configured_out)
1734 * no-inplace copies "thru" outputs (to emulate in-place) for
1735 * all outputs (to prevent overwrite) into a temporary space
1736 * which also holds input buffers (in case the plugin does process
1737 * in-place and overwrites those).
1739 * this buffers need to be at least as
1740 * natural_input_streams () + possible outputs.
1742 * sidechain inputs add a constraint on the input:
1743 * configured input + sidechain (=_configured_internal)
1745 * NB. this also satisfies
1746 * max (natural_input_streams(), natural_output_streams())
1747 * which is needed for silence runs
1749 _required_buffers = ChanCount::max (_configured_internal,
1750 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1752 if (old_in != in || old_out != out || old_internal != _configured_internal
1753 || old_pins != natural_input_streams ()
1754 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1756 PluginIoReConfigure (); /* EMIT SIGNAL */
1759 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1760 _latency_changed = true;
1762 // we don't know the analysis window size, so we must work with the
1763 // current buffer size here. each request for data fills in these
1764 // buffers and the analyser makes sure it gets enough data for the
1766 session().ensure_buffer_set (_signal_analysis_inputs, in);
1767 _signal_analysis_inputs.set_count (in);
1769 session().ensure_buffer_set (_signal_analysis_outputs, out);
1770 _signal_analysis_outputs.set_count (out);
1772 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1775 return Processor::configure_io (in, out);
1778 /** Decide whether this PluginInsert can support a given IO configuration.
1779 * To do this, we run through a set of possible solutions in rough order of
1782 * @param in Required input channel count.
1783 * @param out Filled in with the output channel count if we return true.
1784 * @return true if the given IO configuration can be supported.
1787 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1790 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1792 return private_can_support_io_configuration (in, out).method != Impossible;
1796 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1798 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1799 // preseed hint (for variable i/o)
1800 out.set (DataType::AUDIO, _preset_out.n_audio ());
1803 Match rv = internal_can_support_io_configuration (in, out);
1805 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1806 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: using output preset: %2\n", name(), _preset_out));
1807 out.set (DataType::AUDIO, _preset_out.n_audio ());
1812 /** A private version of can_support_io_configuration which returns the method
1813 * by which the configuration can be matched, rather than just whether or not
1817 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1819 if (_plugins.empty()) {
1824 if (is_channelstrip ()) {
1826 return Match (ExactMatch, 1);
1830 /* if a user specified a custom cfg, so be it. */
1832 PluginInfoPtr info = _plugins.front()->get_info();
1834 if (info->reconfigurable_io()) {
1835 return Match (Delegate, 1, _strict_io, true);
1837 return Match (ExactMatch, get_count(), _strict_io, true);
1841 /* try automatic configuration */
1842 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1844 PluginInfoPtr info = _plugins.front()->get_info();
1845 ChanCount inputs = info->n_inputs;
1846 ChanCount outputs = info->n_outputs;
1848 /* handle case strict-i/o */
1849 if (_strict_io && m.method != Impossible) {
1852 /* special case MIDI instruments */
1853 if (needs_midi_input ()) {
1854 // output = midi-bypass + at most master-out channels.
1855 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1856 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1857 out = ChanCount::min (out, max_out);
1858 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o instrument\n", name()));
1864 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1865 /* replicate processor to match output count (generators and such)
1866 * at least enough to feed every output port. */
1867 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1868 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1869 uint32_t nout = outputs.get (*t);
1870 if (nout == 0 || inx.get(*t) == 0) { continue; }
1871 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1874 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: special case strict-i/o for generator\n", name()));
1875 return Match (Replicate, f, _strict_io);
1886 if (m.method != Impossible) {
1890 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1892 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: resolving 'Impossible' match...\n", name()));
1894 if (info->reconfigurable_io()) {
1897 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1898 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1899 bool const r = _plugins.front()->can_support_io_configuration (inx + sidechain_input_pins (), out, &useins);
1901 // houston, we have a problem.
1902 return Match (Impossible, 0);
1905 if (inx.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
1906 return Match (Delegate, 1, _strict_io);
1909 ChanCount midi_bypass;
1910 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1911 midi_bypass.set (DataType::MIDI, 1);
1914 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1916 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1917 uint32_t nin = ns_inputs.get (*t);
1918 uint32_t nout = outputs.get (*t);
1919 if (nin == 0 || inx.get(*t) == 0) { continue; }
1920 // prefer floor() so the count won't overly increase IFF (nin < nout)
1921 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1923 if (f > 0 && outputs * f >= _configured_out) {
1924 out = outputs * f + midi_bypass;
1925 return Match (Replicate, f, _strict_io);
1928 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1930 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1931 uint32_t nin = ns_inputs.get (*t);
1932 if (nin == 0 || inx.get(*t) == 0) { continue; }
1933 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1936 out = outputs * f + midi_bypass;
1937 return Match (Replicate, f, _strict_io);
1940 // add at least as many plugins needed to connect all inputs
1942 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1943 uint32_t nin = inputs.get (*t);
1944 if (nin == 0 || inx.get(*t) == 0) { continue; }
1945 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1947 out = outputs * f + midi_bypass;
1948 return Match (Replicate, f, _strict_io);
1951 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1953 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1955 if (_plugins.empty()) {
1959 PluginInfoPtr info = _plugins.front()->get_info();
1960 ChanCount in; in += inx;
1961 ChanCount midi_bypass;
1963 if (info->reconfigurable_io()) {
1964 /* Plugin has flexible I/O, so delegate to it
1965 * pre-seed outputs, plugin tries closest match
1968 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1969 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1970 bool const r = _plugins.front()->can_support_io_configuration (in + sidechain_input_pins (), out);
1972 return Match (Impossible, 0);
1975 if (in.n_midi () > 0 && out.n_midi () == 0) { out.set (DataType::MIDI, 1); }
1976 return Match (Delegate, 1);
1979 ChanCount inputs = info->n_inputs;
1980 ChanCount outputs = info->n_outputs;
1981 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1983 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1984 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: bypassing midi-data\n", name()));
1985 midi_bypass.set (DataType::MIDI, 1);
1987 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1988 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: hiding midi-port from plugin\n", name()));
1989 in.set(DataType::MIDI, 0);
1992 // add internally provided sidechain ports
1993 ChanCount insc = in + sidechain_input_ports ();
1995 bool no_inputs = true;
1996 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1997 if (inputs.get (*t) != 0) {
2004 /* no inputs so we can take any input configuration since we throw it away */
2005 out = outputs + midi_bypass;
2006 return Match (NoInputs, 1);
2009 /* Plugin inputs match requested inputs + side-chain-ports exactly */
2010 if (inputs == insc) {
2011 out = outputs + midi_bypass;
2012 return Match (ExactMatch, 1);
2015 /* Plugin inputs matches without side-chain-pins */
2016 if (ns_inputs == in) {
2017 out = outputs + midi_bypass;
2018 return Match (ExactMatch, 1);
2021 /* We may be able to run more than one copy of the plugin within this insert
2022 to cope with the insert having more inputs than the plugin.
2023 We allow replication only for plugins with either zero or 1 inputs and outputs
2024 for every valid data type.
2028 bool can_replicate = true;
2029 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
2031 // ignore side-chains
2032 uint32_t nin = ns_inputs.get (*t);
2034 // No inputs of this type
2035 if (nin == 0 && in.get(*t) == 0) {
2039 if (nin != 1 || outputs.get (*t) != 1) {
2040 can_replicate = false;
2044 // Potential factor not set yet
2046 f = in.get(*t) / nin;
2049 // Factor for this type does not match another type, can not replicate
2050 if (f != (in.get(*t) / nin)) {
2051 can_replicate = false;
2056 if (can_replicate && f > 0) {
2057 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2058 out.set (*t, outputs.get(*t) * f);
2061 return Match (Replicate, f);
2064 /* If the processor has exactly one input of a given type, and
2065 the plugin has more, we can feed the single processor input
2066 to some or all of the plugin inputs. This is rather
2067 special-case-y, but the 1-to-many case is by far the
2068 simplest. How do I split thy 2 processor inputs to 3
2069 plugin inputs? Let me count the ways ...
2072 bool can_split = true;
2073 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2075 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
2076 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
2078 if (!can_split_type && !nothing_to_do_for_type) {
2084 out = outputs + midi_bypass;
2085 return Match (Split, 1);
2088 /* If the plugin has more inputs than we want, we can `hide' some of them
2089 by feeding them silence.
2092 bool could_hide = false;
2093 bool cannot_hide = false;
2094 ChanCount hide_channels;
2096 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2097 if (inputs.get(*t) > in.get(*t)) {
2098 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
2099 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
2101 } else if (inputs.get(*t) < in.get(*t)) {
2102 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
2107 if (could_hide && !cannot_hide) {
2108 out = outputs + midi_bypass;
2109 return Match (Hide, 1, false, false, hide_channels);
2112 return Match (Impossible, 0);
2117 PluginInsert::get_state ()
2119 return state (true);
2123 PluginInsert::state (bool full)
2125 XMLNode& node = Processor::state (full);
2127 node.add_property("type", _plugins[0]->state_node_name());
2128 node.add_property("unique-id", _plugins[0]->unique_id());
2129 node.add_property("count", string_compose("%1", _plugins.size()));
2131 /* remember actual i/o configuration (for later placeholder
2132 * in case the plugin goes missing) */
2133 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
2134 node.add_child_nocopy (* _custom_sinks.state (X_("CustomSinks")));
2135 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
2136 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
2138 /* save custom i/o config */
2139 node.add_property("custom", _custom_cfg ? "yes" : "no");
2140 for (uint32_t pc = 0; pc < get_count(); ++pc) {
2142 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
2143 node.add_child_nocopy (* _in_map[pc].state (tmp));
2144 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
2145 node.add_child_nocopy (* _out_map[pc].state (tmp));
2147 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
2150 node.add_child_nocopy (_sidechain->state (full));
2153 _plugins[0]->set_insert_id(this->id());
2154 node.add_child_nocopy (_plugins[0]->get_state());
2156 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
2157 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
2159 node.add_child_nocopy (ac->get_state());
2167 PluginInsert::set_control_ids (const XMLNode& node, int version)
2169 const XMLNodeList& nlist = node.children();
2170 XMLNodeConstIterator iter;
2171 set<Evoral::Parameter>::const_iterator p;
2173 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
2174 if ((*iter)->name() == Controllable::xml_node_name) {
2175 XMLProperty const * prop;
2177 uint32_t p = (uint32_t)-1;
2179 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
2180 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
2182 p = lv2plugin->port_index(prop->value().c_str());
2186 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
2187 p = atoi (prop->value());
2190 if (p != (uint32_t)-1) {
2192 /* this may create the new controllable */
2194 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
2196 #ifndef NO_PLUGIN_STATE
2200 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
2202 ac->set_state (**iter, version);
2211 PluginInsert::set_state(const XMLNode& node, int version)
2213 XMLNodeList nlist = node.children();
2214 XMLNodeIterator niter;
2215 XMLPropertyList plist;
2216 XMLProperty const * prop;
2217 ARDOUR::PluginType type;
2219 if ((prop = node.property ("type")) == 0) {
2220 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2224 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2225 type = ARDOUR::LADSPA;
2226 } else if (prop->value() == X_("lv2")) {
2228 } else if (prop->value() == X_("windows-vst")) {
2229 type = ARDOUR::Windows_VST;
2230 } else if (prop->value() == X_("lxvst")) {
2231 type = ARDOUR::LXVST;
2232 } else if (prop->value() == X_("audiounit")) {
2233 type = ARDOUR::AudioUnit;
2234 } else if (prop->value() == X_("luaproc")) {
2237 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2243 prop = node.property ("unique-id");
2246 #ifdef WINDOWS_VST_SUPPORT
2247 /* older sessions contain VST plugins with only an "id" field.
2250 if (type == ARDOUR::Windows_VST) {
2251 prop = node.property ("id");
2255 #ifdef LXVST_SUPPORT
2256 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2258 if (type == ARDOUR::LXVST) {
2259 prop = node.property ("id");
2265 error << _("Plugin has no unique ID field") << endmsg;
2270 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2272 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2273 * allow to move sessions windows <> linux */
2274 #ifdef LXVST_SUPPORT
2275 if (plugin == 0 && type == ARDOUR::Windows_VST) {
2276 type = ARDOUR::LXVST;
2277 plugin = find_plugin (_session, prop->value(), type);
2281 #ifdef WINDOWS_VST_SUPPORT
2282 if (plugin == 0 && type == ARDOUR::LXVST) {
2283 type = ARDOUR::Windows_VST;
2284 plugin = find_plugin (_session, prop->value(), type);
2288 if (plugin == 0 && type == ARDOUR::Lua) {
2289 /* unique ID (sha1 of script) was not found,
2290 * load the plugin from the serialized version in the
2291 * session-file instead.
2293 boost::shared_ptr<LuaProc> lp (new LuaProc (_session.engine(), _session, ""));
2294 XMLNode *ls = node.child (lp->state_node_name().c_str());
2296 lp->set_script_from_state (*ls);
2302 error << string_compose(
2303 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2304 "Perhaps it was removed or moved since it was last used."),
2310 // The name of the PluginInsert comes from the plugin, nothing else
2311 _name = plugin->get_info()->name;
2315 // Processor::set_state() will set this, but too late
2316 // for it to be available when setting up plugin
2317 // state. We can't call Processor::set_state() until
2318 // the plugins themselves are created and added.
2322 if (_plugins.empty()) {
2323 /* if we are adding the first plugin, we will need to set
2324 up automatable controls.
2326 add_plugin (plugin);
2327 create_automatable_parameters ();
2328 set_control_ids (node, version);
2331 if ((prop = node.property ("count")) != 0) {
2332 sscanf (prop->value().c_str(), "%u", &count);
2335 if (_plugins.size() != count) {
2336 for (uint32_t n = 1; n < count; ++n) {
2337 add_plugin (plugin_factory (plugin));
2341 Processor::set_state (node, version);
2343 PBD::ID new_id = this->id();
2344 PBD::ID old_id = this->id();
2346 if ((prop = node.property ("id")) != 0) {
2347 old_id = prop->value ();
2350 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2352 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2353 and set all plugins to the same state.
2356 if ((*niter)->name() == plugin->state_node_name()) {
2358 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2359 /* Plugin state can include external files which are named after the ID.
2361 * If regenerate_xml_or_string_ids() is set, the ID will already have
2362 * been changed, so we need to use the old ID from the XML to load the
2363 * state and then update the ID.
2365 * When copying a plugin-state, route_ui takes care of of updating the ID,
2366 * but we need to call set_insert_id() to clear the cached plugin-state
2367 * and force a change.
2369 if (!regenerate_xml_or_string_ids ()) {
2370 (*i)->set_insert_id (new_id);
2372 (*i)->set_insert_id (old_id);
2375 (*i)->set_state (**niter, version);
2377 if (regenerate_xml_or_string_ids ()) {
2378 (*i)->set_insert_id (new_id);
2386 if (version < 3000) {
2388 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2389 this is all handled by Automatable
2392 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2393 if ((*niter)->name() == "Redirect") {
2394 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2395 Processor::set_state (**niter, version);
2400 set_parameter_state_2X (node, version);
2403 if ((prop = node.property (X_("custom"))) != 0) {
2404 _custom_cfg = string_is_affirmative (prop->value());
2407 uint32_t in_maps = 0;
2408 uint32_t out_maps = 0;
2409 XMLNodeList kids = node.children ();
2410 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2411 if ((*i)->name() == X_("ConfiguredInput")) {
2412 _configured_in = ChanCount(**i);
2414 if ((*i)->name() == X_("CustomSinks")) {
2415 _custom_sinks = ChanCount(**i);
2417 if ((*i)->name() == X_("ConfiguredOutput")) {
2418 _custom_out = ChanCount(**i);
2419 _configured_out = ChanCount(**i);
2421 if ((*i)->name() == X_("PresetOutput")) {
2422 _preset_out = ChanCount(**i);
2424 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2425 long pc = atol (&((*i)->name().c_str()[9]));
2426 if (pc >= 0 && pc <= (long) get_count()) {
2427 _in_map[pc] = ChanMapping (**i);
2431 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2432 long pc = atol (&((*i)->name().c_str()[10]));
2433 if (pc >= 0 && pc <= (long) get_count()) {
2434 _out_map[pc] = ChanMapping (**i);
2438 if ((*i)->name () == "ThruMap") {
2439 _thru_map = ChanMapping (**i);
2442 // sidechain is a Processor (IO)
2443 if ((*i)->name () == Processor::state_node_name) {
2447 _sidechain->set_state (**i, version);
2451 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2452 _maps_from_state = true;
2455 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2459 (*i)->deactivate ();
2463 PluginConfigChanged (); /* EMIT SIGNAL */
2468 PluginInsert::update_id (PBD::ID id)
2471 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2472 (*i)->set_insert_id (id);
2477 PluginInsert::set_state_dir (const std::string& d)
2479 // state() only saves the state of the first plugin
2480 _plugins[0]->set_state_dir (d);
2484 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2486 XMLNodeList nlist = node.children();
2487 XMLNodeIterator niter;
2489 /* look for port automation node */
2491 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2493 if ((*niter)->name() != port_automation_node_name) {
2498 XMLProperty const * cprop;
2499 XMLNodeConstIterator iter;
2504 cnodes = (*niter)->children ("port");
2506 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2510 if ((cprop = child->property("number")) != 0) {
2511 port = cprop->value().c_str();
2513 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2517 sscanf (port, "%" PRIu32, &port_id);
2519 if (port_id >= _plugins[0]->parameter_count()) {
2520 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2524 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2525 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2527 if (c && c->alist()) {
2528 if (!child->children().empty()) {
2529 c->alist()->set_state (*child->children().front(), version);
2531 /* In some cases 2.X saves lists with min_yval and max_yval
2532 being FLT_MIN and FLT_MAX respectively. This causes problems
2533 in A3 because these min/max values are used to compute
2534 where GUI control points should be drawn. If we see such
2535 values, `correct' them to the min/max of the appropriate
2539 float min_y = c->alist()->get_min_y ();
2540 float max_y = c->alist()->get_max_y ();
2542 ParameterDescriptor desc;
2543 _plugins.front()->get_parameter_descriptor (port_id, desc);
2545 if (min_y == FLT_MIN) {
2549 if (max_y == FLT_MAX) {
2553 c->alist()->set_yrange (min_y, max_y);
2556 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2568 PluginInsert::describe_parameter (Evoral::Parameter param)
2570 if (param.type() == PluginAutomation) {
2571 return _plugins[0]->describe_parameter (param);
2572 } else if (param.type() == PluginPropertyAutomation) {
2573 boost::shared_ptr<AutomationControl> c(automation_control(param));
2574 if (c && !c->desc().label.empty()) {
2575 return c->desc().label;
2578 return Automatable::describe_parameter(param);
2582 PluginInsert::signal_latency() const
2584 if (_user_latency) {
2585 return _user_latency;
2588 return _plugins[0]->signal_latency ();
2592 PluginInsert::type ()
2594 return plugin()->get_info()->type;
2597 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2598 const Evoral::Parameter& param,
2599 const ParameterDescriptor& desc,
2600 boost::shared_ptr<AutomationList> list)
2601 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2605 alist()->reset_default (desc.normal);
2607 list->set_interpolation(Evoral::ControlList::Discrete);
2612 set_flags(Controllable::Toggle);
2616 /** @param val `user' value */
2618 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2621 _set_value (user_val, group_override);
2625 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2627 /* used only by automation playback */
2628 _set_value (user_val, Controllable::NoGroup);
2632 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2634 /* FIXME: probably should be taking out some lock here.. */
2636 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2637 (*i)->set_parameter (_list->parameter().id(), user_val);
2640 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2642 iasp->set_parameter (_list->parameter().id(), user_val);
2645 AutomationControl::set_value (user_val, group_override);
2649 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2651 AutomationControl::set_value (user_val, Controllable::NoGroup);
2655 PluginInsert::PluginControl::get_state ()
2659 XMLNode& node (AutomationControl::get_state());
2660 ss << parameter().id();
2661 node.add_property (X_("parameter"), ss.str());
2663 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2665 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2672 /** @return `user' val */
2674 PluginInsert::PluginControl::get_value () const
2676 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2682 return plugin->get_parameter (_list->parameter().id());
2685 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2686 const Evoral::Parameter& param,
2687 const ParameterDescriptor& desc,
2688 boost::shared_ptr<AutomationList> list)
2689 : AutomationControl (p->session(), param, desc, list)
2693 alist()->set_yrange (desc.lower, desc.upper);
2694 alist()->reset_default (desc.normal);
2698 set_flags(Controllable::Toggle);
2703 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2706 set_value_unchecked (user_val);
2711 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2713 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2714 This is lossy, but better than nothing until Ardour's automation system
2715 can handle various datatypes all the way down. */
2716 const Variant value(_desc.datatype, user_val);
2717 if (value.type() == Variant::NOTHING) {
2718 error << "set_value(double) called for non-numeric property" << endmsg;
2722 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2723 (*i)->set_property(_list->parameter().id(), value);
2727 AutomationControl::set_value (user_val, Controllable::NoGroup);
2731 PluginInsert::PluginPropertyControl::get_state ()
2735 XMLNode& node (AutomationControl::get_state());
2736 ss << parameter().id();
2737 node.add_property (X_("property"), ss.str());
2738 node.remove_property (X_("value"));
2744 PluginInsert::PluginPropertyControl::get_value () const
2746 return _value.to_double();
2749 boost::shared_ptr<Plugin>
2750 PluginInsert::get_impulse_analysis_plugin()
2752 boost::shared_ptr<Plugin> ret;
2753 if (_impulseAnalysisPlugin.expired()) {
2754 // LV2 in particular uses various _session params
2755 // during init() -- most notably block_size..
2757 ret = plugin_factory(_plugins[0]);
2758 ret->configure_io (internal_input_streams (), internal_output_streams ());
2759 _impulseAnalysisPlugin = ret;
2761 ret = _impulseAnalysisPlugin.lock();
2768 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2770 // called from outside the audio thread, so this should be safe
2771 // only do audio as analysis is (currently) only for audio plugins
2772 _signal_analysis_inputs.ensure_buffers (DataType::AUDIO, input_streams().n_audio(), nframes);
2773 _signal_analysis_outputs.ensure_buffers (DataType::AUDIO, output_streams().n_audio(), nframes);
2775 _signal_analysis_collected_nframes = 0;
2776 _signal_analysis_collect_nframes_max = nframes;
2779 /** Add a plugin to our list */
2781 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2783 plugin->set_insert_id (this->id());
2785 if (_plugins.empty()) {
2786 /* first (and probably only) plugin instance - connect to relevant signals */
2788 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2789 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2790 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2791 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2792 _custom_sinks = plugin->get_info()->n_inputs;
2793 // cache sidechain port count
2794 _cached_sidechain_pins.reset ();
2795 const ChanCount& nis (plugin->get_info()->n_inputs);
2796 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2797 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2798 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2799 if (iod.is_sidechain) {
2800 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2805 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2806 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2808 vst->set_insert (this, _plugins.size ());
2811 _plugins.push_back (plugin);
2815 PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
2818 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2819 if (! (*i)->load_preset (pr)) {
2827 PluginInsert::realtime_handle_transport_stopped ()
2829 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2830 (*i)->realtime_handle_transport_stopped ();
2835 PluginInsert::realtime_locate ()
2837 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2838 (*i)->realtime_locate ();
2843 PluginInsert::monitoring_changed ()
2845 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2846 (*i)->monitoring_changed ();
2851 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2853 // this is called in RT context, LatencyChanged is emitted after run()
2854 _latency_changed = true;
2858 PluginInsert::start_touch (uint32_t param_id)
2860 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2862 ac->start_touch (session().audible_frame());
2867 PluginInsert::end_touch (uint32_t param_id)
2869 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2871 ac->stop_touch (true, session().audible_frame());
2875 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2878 case PluginInsert::Impossible: o << "Impossible"; break;
2879 case PluginInsert::Delegate: o << "Delegate"; break;
2880 case PluginInsert::NoInputs: o << "NoInputs"; break;
2881 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2882 case PluginInsert::Replicate: o << "Replicate"; break;
2883 case PluginInsert::Split: o << "Split"; break;
2884 case PluginInsert::Hide: o << "Hide"; break;
2886 o << " cnt: " << m.plugins
2887 << (m.strict_io ? " strict-io" : "")
2888 << (m.custom_cfg ? " custom-cfg" : "");
2889 if (m.method == PluginInsert::Hide) {
2890 o << " hide: " << m.hide;