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"
41 #include "ardour/lv2_plugin.h"
44 #ifdef WINDOWS_VST_SUPPORT
45 #include "ardour/windows_vst_plugin.h"
49 #include "ardour/lxvst_plugin.h"
52 #ifdef AUDIOUNIT_SUPPORT
53 #include "ardour/audio_unit.h"
56 #include "ardour/session.h"
57 #include "ardour/types.h"
62 using namespace ARDOUR;
65 const string PluginInsert::port_automation_node_name = "PortAutomation";
67 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
68 : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
69 , _signal_analysis_collected_nframes(0)
70 , _signal_analysis_collect_nframes_max(0)
75 , _maps_from_state (false)
77 /* the first is the master */
81 create_automatable_parameters ();
82 const ChanCount& sc (sidechain_input_pins ());
83 if (sc.n_audio () > 0) {
84 add_sidechain (sc.n_audio ());
89 PluginInsert::~PluginInsert ()
94 PluginInsert::set_strict_io (bool b)
96 bool changed = _strict_io != b;
99 PluginConfigChanged (); /* EMIT SIGNAL */
104 PluginInsert::set_count (uint32_t num)
106 bool require_state = !_plugins.empty();
108 /* this is a bad idea.... we shouldn't do this while active.
109 only a route holding their redirect_lock should be calling this
114 } else if (num > _plugins.size()) {
115 uint32_t diff = num - _plugins.size();
117 for (uint32_t n = 0; n < diff; ++n) {
118 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
125 /* XXX do something */
128 PluginConfigChanged (); /* EMIT SIGNAL */
130 } else if (num < _plugins.size()) {
131 uint32_t diff = _plugins.size() - num;
132 for (uint32_t n= 0; n < diff; ++n) {
135 PluginConfigChanged (); /* EMIT SIGNAL */
143 PluginInsert::set_outputs (const ChanCount& c)
145 bool changed = (_custom_out != c) && _custom_cfg;
148 PluginConfigChanged (); /* EMIT SIGNAL */
153 PluginInsert::set_custom_cfg (bool b)
155 bool changed = _custom_cfg != b;
158 PluginConfigChanged (); /* EMIT SIGNAL */
163 PluginInsert::add_sidechain (uint32_t n_audio)
165 // caller must hold process lock
169 std::ostringstream n;
171 n << "Sidechain " << Session::next_name_id ();
173 n << "TO BE RESET FROM XML";
175 SideChain *sc = new SideChain (_session, n.str ());
176 _sidechain = boost::shared_ptr<SideChain> (sc);
177 _sidechain->activate ();
178 for (uint32_t n = 0; n < n_audio; ++n) {
179 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
181 PluginConfigChanged (); /* EMIT SIGNAL */
186 PluginInsert::del_sidechain ()
192 PluginConfigChanged (); /* EMIT SIGNAL */
197 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
199 if (which.type() != PluginAutomation)
202 boost::shared_ptr<AutomationControl> c
203 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
206 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
211 PluginInsert::output_streams() const
213 assert (_configured);
214 return _configured_out;
218 PluginInsert::input_streams() const
220 assert (_configured);
221 return _configured_in;
225 PluginInsert::internal_streams() const
227 assert (_configured);
228 return _configured_internal;
232 PluginInsert::internal_output_streams() const
234 assert (!_plugins.empty());
236 PluginInfoPtr info = _plugins.front()->get_info();
238 if (info->reconfigurable_io()) {
239 ChanCount out = _plugins.front()->output_streams ();
240 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
243 ChanCount out = info->n_outputs;
244 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
245 out.set_audio (out.n_audio() * _plugins.size());
246 out.set_midi (out.n_midi() * _plugins.size());
252 PluginInsert::internal_input_streams() const
254 assert (!_plugins.empty());
258 PluginInfoPtr info = _plugins.front()->get_info();
260 if (info->reconfigurable_io()) {
261 assert (_plugins.size() == 1);
262 in = _plugins.front()->input_streams();
267 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
269 if (_match.method == Split) {
271 /* we are splitting 1 processor input to multiple plugin inputs,
272 so we have a maximum of 1 stream of each type.
274 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
275 if (in.get (*t) > 1) {
281 } else if (_match.method == Hide) {
283 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
284 in.set (*t, in.get (*t) - _match.hide.get (*t));
290 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
291 in.set (*t, in.get (*t) * _plugins.size ());
299 PluginInsert::natural_output_streams() const
302 if (is_channelstrip ()) {
303 return _configured_out;
306 return _plugins[0]->get_info()->n_outputs;
310 PluginInsert::natural_input_streams() const
313 if (is_channelstrip ()) {
314 return _configured_in;
317 return _plugins[0]->get_info()->n_inputs;
321 PluginInsert::sidechain_input_pins() const
323 return _cached_sidechain_pins;
327 PluginInsert::has_no_inputs() const
329 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
333 PluginInsert::has_no_audio_inputs() const
335 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
339 PluginInsert::plugin_latency () const {
340 return _plugins.front()->signal_latency ();
344 PluginInsert::is_midi_instrument() const
346 /* XXX more finesse is possible here. VST plugins have a
347 a specific "instrument" flag, for example.
349 PluginInfoPtr pi = _plugins[0]->get_info();
351 return pi->n_inputs.n_midi() != 0 &&
352 pi->n_outputs.n_audio() > 0;
356 PluginInsert::create_automatable_parameters ()
358 assert (!_plugins.empty());
360 set<Evoral::Parameter> a = _plugins.front()->automatable ();
362 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
363 if (i->type() == PluginAutomation) {
365 Evoral::Parameter param(*i);
367 ParameterDescriptor desc;
368 _plugins.front()->get_parameter_descriptor(i->id(), desc);
370 can_automate (param);
371 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
372 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
374 _plugins.front()->set_automation_control (i->id(), c);
375 } else if (i->type() == PluginPropertyAutomation) {
376 Evoral::Parameter param(*i);
377 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
378 if (desc.datatype != Variant::NOTHING) {
379 boost::shared_ptr<AutomationList> list;
380 if (Variant::type_is_numeric(desc.datatype)) {
381 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
383 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
388 /** Called when something outside of this host has modified a plugin
389 * parameter. Responsible for propagating the change to two places:
391 * 1) anything listening to the Control itself
392 * 2) any replicated plugins that make up this PluginInsert.
394 * The PluginInsert is connected to the ParameterChangedExternally signal for
395 * the first (primary) plugin, and here broadcasts that change to any others.
397 * XXX We should probably drop this whole replication idea (Paul, October 2015)
398 * since it isn't used by sensible plugin APIs (AU, LV2).
401 PluginInsert::parameter_changed_externally (uint32_t which, float val)
403 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
405 /* First propagation: alter the underlying value of the control,
406 * without telling the plugin(s) that own/use it to set it.
413 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
416 pc->catch_up_with_external_value (val);
419 /* Second propagation: tell all plugins except the first to
420 update the value of this parameter. For sane plugin APIs,
421 there are no other plugins, so this is a no-op in those
425 Plugins::iterator i = _plugins.begin();
427 /* don't set the first plugin, just all the slaves */
429 if (i != _plugins.end()) {
431 for (; i != _plugins.end(); ++i) {
432 (*i)->set_parameter (which, val);
438 PluginInsert::set_block_size (pframes_t nframes)
441 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
442 if ((*i)->set_block_size (nframes) != 0) {
450 PluginInsert::activate ()
452 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
456 Processor::activate ();
460 PluginInsert::deactivate ()
462 Processor::deactivate ();
464 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
470 PluginInsert::flush ()
472 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
478 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
480 // TODO: atomically copy maps & _no_inplace
481 PinMappings in_map (_in_map);
482 PinMappings out_map (_out_map);
483 ChanMapping thru_map (_thru_map);
484 if (_mapping_changed) { // ToDo use a counters, increment until match.
485 _no_inplace = check_inplace ();
486 _mapping_changed = false;
489 if (_latency_changed) {
490 /* delaylines are configured with the max possible latency (as reported by the plugin)
491 * so this won't allocate memory (unless the plugin lied about its max latency)
492 * It may still 'click' though, since the fixed delaylines are not de-clicked.
493 * Then again plugin-latency changes are not click-free to begin with.
495 * This is also worst case, there is currently no concept of per-stream latency.
497 * e.g. Two identical latent plugins:
498 * 1st plugin: process left (latent), bypass right.
499 * 2nd plugin: bypass left, process right (latent).
500 * -> currently this yields 2 times latency of the plugin,
502 _latency_changed = false;
503 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
506 if (_match.method == Split && !_no_inplace) {
507 // TODO: also use this optimization if one source-buffer
508 // feeds _all_ *connected* inputs.
509 // currently this is *first* buffer to all only --
510 // see PluginInsert::check_inplace
511 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
512 if (_configured_internal.get (*t) == 0) {
516 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
517 assert (valid && first_idx == 0); // check_inplace ensures this
518 /* copy the first stream's buffer contents to the others */
519 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
520 uint32_t idx = in_map[0].get (*t, i, &valid);
523 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
527 /* the copy operation produces a linear monotonic input map */
528 in_map[0] = ChanMapping (natural_input_streams ());
531 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
532 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
538 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
540 boost::shared_ptr<AutomationControl> c
541 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
543 if (c->list() && c->automation_playback()) {
546 const float val = c->list()->rt_safe_eval (now, valid);
549 /* This is the ONLY place where we are
551 * AutomationControl::set_value_unchecked(). We
552 * know that the control is in
553 * automation playback mode, so no
554 * check on writable() is required
555 * (which must be done in AutomationControl::set_value()
558 c->set_value_unchecked(val);
565 /* Calculate if, and how many frames we need to collect for analysis */
566 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
567 _signal_analysis_collected_nframes);
568 if (nframes < collect_signal_nframes) { // we might not get all frames now
569 collect_signal_nframes = nframes;
572 if (collect_signal_nframes > 0) {
574 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
575 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
576 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
578 _signal_analysis_inputs.set_count(internal_input_streams());
580 for (uint32_t i = 0; i < internal_input_streams().n_audio(); ++i) {
581 _signal_analysis_inputs.get_audio(i).read_from(
583 collect_signal_nframes,
584 _signal_analysis_collected_nframes); // offset is for target buffer
589 if (is_channelstrip ()) {
590 if (_configured_in.n_audio() > 0) {
591 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
592 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
594 _plugins.front()->connect_and_run (bufs, mb_in_map, mb_out_map, nframes, offset);
596 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
597 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
603 // TODO optimize -- build maps once.
605 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
606 ARDOUR::ChanMapping used_outputs;
608 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
610 /* build used-output map */
611 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
612 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
613 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
615 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
617 used_outputs.set (*t, out_idx, 1); // mark as used
622 /* copy thru data to outputs before processing in-place */
623 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
624 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
626 uint32_t in_idx = thru_map.get (*t, out, &valid);
628 uint32_t m = out + natural_input_streams ().get (*t);
629 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
630 used_outputs.set (*t, out, 1); // mark as used
636 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
638 ARDOUR::ChanMapping i_in_map (natural_input_streams());
639 ARDOUR::ChanMapping i_out_map (out_map[pc]);
640 ARDOUR::ChanCount mapped;
642 /* map inputs sequentially */
643 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
644 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
646 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
647 uint32_t m = mapped.get (*t);
649 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
651 inplace_bufs.get (*t, m).silence (nframes, offset);
653 mapped.set (*t, m + 1);
657 /* outputs are mapped to inplace_bufs after the inputs */
658 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
659 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
662 if ((*i)->connect_and_run (inplace_bufs, i_in_map, i_out_map, nframes, offset)) {
667 /* all instances have completed, now copy data that was written
668 * and zero unconnected buffers */
669 ARDOUR::ChanMapping nonzero_out (used_outputs);
670 if (has_midi_bypass ()) {
671 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
673 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
674 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
676 used_outputs.get (*t, out, &valid);
678 nonzero_out.get (*t, out, &valid);
680 bufs.get (*t, out).silence (nframes, offset);
683 uint32_t m = out + natural_input_streams ().get (*t);
684 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
689 /* in-place processing */
691 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
692 if ((*i)->connect_and_run(bufs, in_map[pc], out_map[pc], nframes, offset)) {
697 // TODO optimize: store "unconnected" in a fixed set.
698 // it only changes on reconfiguration.
699 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
700 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
702 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
703 mapped = true; // in-place Midi bypass
705 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
706 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
708 uint32_t idx = out_map[pc].get (*t, o, &valid);
709 if (valid && idx == out) {
716 bufs.get (*t, out).silence (nframes, offset);
722 if (collect_signal_nframes > 0) {
724 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
725 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
727 _signal_analysis_outputs.set_count(internal_output_streams());
729 for (uint32_t i = 0; i < internal_output_streams().n_audio(); ++i) {
730 _signal_analysis_outputs.get_audio(i).read_from(
732 collect_signal_nframes,
733 _signal_analysis_collected_nframes); // offset is for target buffer
736 _signal_analysis_collected_nframes += collect_signal_nframes;
737 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
739 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
740 _signal_analysis_collect_nframes_max = 0;
741 _signal_analysis_collected_nframes = 0;
743 AnalysisDataGathered(&_signal_analysis_inputs,
744 &_signal_analysis_outputs);
750 PluginInsert::silence (framecnt_t nframes)
756 ChanMapping in_map (natural_input_streams ());
757 ChanMapping out_map (natural_output_streams ());
759 // TODO run sidechain (delaylines)
760 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
761 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
766 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
768 if (_pending_active) {
769 /* run as normal if we are active or moving from inactive to active */
772 // collect sidechain input for complete cycle (!)
773 // TODO we need delaylines here for latency compensation
774 _sidechain->run (bufs, start_frame, end_frame, nframes, true);
777 if (_session.transport_rolling() || _session.bounce_processing()) {
778 automation_run (bufs, start_frame, nframes);
780 connect_and_run (bufs, nframes, 0, false);
784 // TODO use mapping in bypassed mode ?!
785 // -> do we bypass the processor or the plugin
787 // TODO include sidechain??
789 uint32_t in = input_streams ().n_audio ();
790 uint32_t out = output_streams().n_audio ();
792 if (has_no_audio_inputs() || in == 0) {
794 /* silence all (audio) outputs. Should really declick
795 * at the transitions of "active"
798 for (uint32_t n = 0; n < out; ++n) {
799 bufs.get_audio (n).silence (nframes);
802 } else if (out > in) {
804 /* not active, but something has make up for any channel count increase
805 * for now , simply replicate last buffer
807 for (uint32_t n = in; n < out; ++n) {
808 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
812 bufs.count().set_audio (out);
815 _active = _pending_active;
817 /* we have no idea whether the plugin generated silence or not, so mark
818 * all buffers appropriately.
823 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
825 Evoral::ControlEvent next_event (0, 0.0f);
826 framepos_t now = start;
827 framepos_t end = now + nframes;
828 framecnt_t offset = 0;
830 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
833 connect_and_run (bufs, nframes, offset, false);
837 if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
839 /* no events have a time within the relevant range */
841 connect_and_run (bufs, nframes, offset, true, now);
847 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
849 connect_and_run (bufs, cnt, offset, true, now);
855 if (!find_next_event (now, end, next_event)) {
860 /* cleanup anything that is left to do */
863 connect_and_run (bufs, nframes, offset, true, now);
868 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
870 if (param.type() != PluginAutomation)
873 if (_plugins.empty()) {
874 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
876 abort(); /*NOTREACHED*/
879 return _plugins[0]->default_value (param.id());
884 PluginInsert::can_reset_all_parameters ()
888 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
890 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
892 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
896 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
902 if (ac->automation_state() & Play) {
907 return all && (params > 0);
911 PluginInsert::reset_parameters_to_default ()
915 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
917 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
919 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
923 const float dflt = _plugins[0]->default_value (cid);
924 const float curr = _plugins[0]->get_parameter (cid);
930 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
935 if (ac->automation_state() & Play) {
940 ac->set_value (dflt, Controllable::NoGroup);
945 boost::shared_ptr<Plugin>
946 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
948 boost::shared_ptr<LadspaPlugin> lp;
949 boost::shared_ptr<LuaProc> lua;
951 boost::shared_ptr<LV2Plugin> lv2p;
953 #ifdef WINDOWS_VST_SUPPORT
954 boost::shared_ptr<WindowsVSTPlugin> vp;
957 boost::shared_ptr<LXVSTPlugin> lxvp;
959 #ifdef AUDIOUNIT_SUPPORT
960 boost::shared_ptr<AUPlugin> ap;
963 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
964 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
965 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
966 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
968 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
969 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
971 #ifdef WINDOWS_VST_SUPPORT
972 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
973 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
976 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
977 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
979 #ifdef AUDIOUNIT_SUPPORT
980 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
981 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
985 fatal << string_compose (_("programming error: %1"),
986 X_("unknown plugin type in PluginInsert::plugin_factory"))
988 abort(); /*NOTREACHED*/
989 return boost::shared_ptr<Plugin> ((Plugin*) 0);
993 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
994 if (num < _in_map.size()) {
995 bool changed = _in_map[num] != m;
997 changed |= sanitize_maps ();
999 PluginMapChanged (); /* EMIT SIGNAL */
1000 _mapping_changed = true;
1001 _session.set_dirty();
1007 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1008 if (num < _out_map.size()) {
1009 bool changed = _out_map[num] != m;
1011 changed |= sanitize_maps ();
1013 PluginMapChanged (); /* EMIT SIGNAL */
1014 _mapping_changed = true;
1015 _session.set_dirty();
1021 PluginInsert::set_thru_map (ChanMapping m) {
1022 bool changed = _thru_map != m;
1024 changed |= sanitize_maps ();
1026 PluginMapChanged (); /* EMIT SIGNAL */
1027 _mapping_changed = true;
1028 _session.set_dirty();
1033 PluginInsert::input_map () const
1037 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1038 ChanMapping m (i->second);
1039 const ChanMapping::Mappings& mp ((*i).second.mappings());
1040 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1041 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1042 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1050 PluginInsert::output_map () const
1054 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1055 ChanMapping m (i->second);
1056 const ChanMapping::Mappings& mp ((*i).second.mappings());
1057 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1058 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1059 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1063 if (has_midi_bypass ()) {
1064 rv.set (DataType::MIDI, 0, 0);
1071 PluginInsert::has_midi_bypass () const
1073 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1074 && natural_output_streams ().n_midi () == 0) {
1081 PluginInsert::has_midi_thru () const
1083 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1084 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1092 PluginInsert::is_channelstrip () const {
1093 return _plugins.front()->is_channelstrip();
1098 PluginInsert::check_inplace ()
1100 bool inplace_ok = !_plugins.front()->inplace_broken ();
1102 if (_thru_map.n_total () > 0) {
1103 // TODO once midi-bypass is part of the mapping, ignore it
1107 if (_match.method == Split && inplace_ok) {
1108 assert (get_count() == 1);
1109 assert (_in_map.size () == 1);
1110 if (!_out_map[0].is_monotonic ()) {
1113 if (_configured_internal != _configured_in) {
1114 /* no sidechain -- TODO we could allow this with
1115 * some more logic in PluginInsert::connect_and_run().
1117 * PluginInsert::reset_map() already maps it.
1122 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1123 if (_configured_internal.get (*t) == 0) {
1127 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1128 if (!valid || first_idx != 0) {
1129 // so far only allow to copy the *first* stream's buffer to others
1132 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1133 uint32_t idx = _in_map[0].get (*t, i, &valid);
1134 if (valid && idx != first_idx) {
1143 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1148 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1149 if (!_in_map[pc].is_monotonic ()) {
1152 if (!_out_map[pc].is_monotonic ()) {
1156 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1157 return !inplace_ok; // no-inplace
1161 PluginInsert::sanitize_maps ()
1163 bool changed = false;
1164 /* strip dead wood */
1165 PinMappings new_ins;
1166 PinMappings new_outs;
1167 ChanMapping new_thru (_thru_map);
1169 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1171 ChanMapping new_out;
1172 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1173 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1175 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1176 if (valid && idx < _configured_internal.get (*t)) {
1177 new_in.set (*t, i, idx);
1180 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1182 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1183 if (valid && idx < _configured_out.get (*t)) {
1184 new_out.set (*t, o, idx);
1188 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1191 new_ins[pc] = new_in;
1192 new_outs[pc] = new_out;
1195 /* prevent dup output assignments */
1196 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1197 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1198 bool mapped = false;
1199 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1201 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1202 if (valid && mapped) {
1203 new_outs[pc].unset (*t, idx);
1211 /* prevent out + thru, existing plugin outputs override thru */
1212 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1213 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1214 bool mapped = false;
1216 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1217 new_outs[pc].get_src (*t, o, &mapped);
1218 if (mapped) { break; }
1220 if (!mapped) { continue; }
1221 uint32_t idx = new_thru.get (*t, o, &valid);
1223 new_thru.unset (*t, idx);
1228 if (has_midi_bypass ()) {
1229 // TODO: include midi-bypass in the thru set,
1230 // remove dedicated handling.
1231 new_thru.unset (DataType::MIDI, 0);
1234 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1238 _out_map = new_outs;
1239 _thru_map = new_thru;
1245 PluginInsert::reset_map (bool emit)
1247 const PinMappings old_in (_in_map);
1248 const PinMappings old_out (_out_map);
1252 _thru_map = ChanMapping ();
1254 /* build input map */
1255 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1256 uint32_t sc = 0; // side-chain round-robin (all instances)
1258 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1259 const uint32_t nis = natural_input_streams ().get(*t);
1260 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1262 /* SC inputs are last in the plugin-insert.. */
1263 const uint32_t sc_start = _configured_in.get (*t);
1264 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1265 /* ...but may not be at the end of the plugin ports.
1266 * in case the side-chain is not the last port, shift connections back.
1267 * and connect to side-chain
1270 uint32_t ic = 0; // split inputs
1271 const uint32_t cend = _configured_in.get (*t);
1273 for (uint32_t in = 0; in < nis; ++in) {
1274 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1275 if (iod.is_sidechain) {
1276 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1277 if (sc_len > 0) {// side-chain may be hidden
1278 _in_map[pc].set (*t, in, sc_start + sc);
1279 sc = (sc + 1) % sc_len;
1283 if (_match.method == Split) {
1284 if (cend == 0) { continue; }
1285 /* connect *no* sidechain sinks in round-robin fashion */
1286 _in_map[pc].set (*t, in, ic + stride * pc);
1287 ic = (ic + 1) % cend;
1289 uint32_t s = in - shift;
1290 if (stride * pc + s < cend) {
1291 _in_map[pc].set (*t, in, stride * pc + s);
1299 /* build output map */
1301 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1302 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1303 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1304 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1309 if (old_in == _in_map && old_out == _out_map) {
1313 PluginMapChanged (); /* EMIT SIGNAL */
1314 _mapping_changed = true;
1315 _session.set_dirty();
1321 PluginInsert::configure_io (ChanCount in, ChanCount out)
1323 Match old_match = _match;
1325 ChanCount old_internal;
1329 old_in = _configured_in;
1330 old_internal = _configured_internal;
1331 old_out = _configured_out;
1334 _configured_in = in;
1335 _configured_internal = in;
1336 _configured_out = out;
1339 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1340 * (currently _sidechain->configure_io always succeeds
1341 * since Processor::configure_io() succeeds)
1343 if (!_sidechain->configure_io (in, out)) {
1344 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1347 _configured_internal += _sidechain->input()->n_ports();
1350 /* get plugin configuration */
1351 _match = private_can_support_io_configuration (in, out);
1353 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1355 DEBUG_STR_APPEND(a, string_compose ("Match '%1': ", name()));
1356 DEBUG_STR_APPEND(a, _match);
1357 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1361 /* set the matching method and number of plugins that we will use to meet this configuration */
1362 if (set_count (_match.plugins) == false) {
1363 PluginIoReConfigure (); /* EMIT SIGNAL */
1364 _configured = false;
1368 /* configure plugins */
1369 switch (_match.method) {
1372 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1373 PluginIoReConfigure (); /* EMIT SIGNAL */
1374 _configured = false;
1382 bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1384 assert (_match.strict_io || dout.n_audio() == out.n_audio()); // sans midi bypass
1385 if (useins.n_audio() == 0) {
1388 if (_plugins.front()->configure_io (useins, dout) == false) {
1389 PluginIoReConfigure (); /* EMIT SIGNAL */
1390 _configured = false;
1396 if (_plugins.front()->configure_io (in, out) == false) {
1397 PluginIoReConfigure (); /* EMIT SIGNAL */
1398 _configured = false;
1404 bool mapping_changed = false;
1405 if (old_in == in && old_out == out
1407 && old_match.method == _match.method
1408 && _in_map.size() == _out_map.size()
1409 && _in_map.size() == get_count ()
1411 /* If the configuration has not changed, keep the mapping */
1412 if (old_internal != _configured_internal) {
1413 mapping_changed = sanitize_maps ();
1415 } else if (_match.custom_cfg && _configured) {
1416 mapping_changed = sanitize_maps ();
1419 if (is_channelstrip ()) { _maps_from_state = false; }
1421 if (_maps_from_state) {
1422 _maps_from_state = false;
1423 mapping_changed = true;
1426 /* generate a new mapping */
1427 mapping_changed = reset_map (false);
1431 if (mapping_changed) {
1432 PluginMapChanged (); /* EMIT SIGNAL */
1435 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1438 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1439 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1441 DEBUG_STR_APPEND(a, "----><----\n");
1443 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1444 DEBUG_STR_APPEND(a, " * Inputs:\n");
1445 DEBUG_STR_APPEND(a, _in_map[pc]);
1446 DEBUG_STR_APPEND(a, " * Outputs:\n");
1447 DEBUG_STR_APPEND(a, _out_map[pc]);
1449 DEBUG_STR_APPEND(a, " * Thru:\n");
1450 DEBUG_STR_APPEND(a, _thru_map);
1451 DEBUG_STR_APPEND(a, "-------->>--------\n");
1452 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1457 _no_inplace = check_inplace ();
1458 _mapping_changed = false;
1460 if (old_in != in || old_out != out || old_internal != _configured_internal
1461 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1463 PluginIoReConfigure (); /* EMIT SIGNAL */
1466 _delaybuffers.configure (_configured_out, _plugins.front()->max_latency ());
1467 _latency_changed = true;
1469 // we don't know the analysis window size, so we must work with the
1470 // current buffer size here. each request for data fills in these
1471 // buffers and the analyser makes sure it gets enough data for the
1473 session().ensure_buffer_set (_signal_analysis_inputs, in);
1474 //_signal_analysis_inputs.set_count (in);
1476 session().ensure_buffer_set (_signal_analysis_outputs, out);
1477 //_signal_analysis_outputs.set_count (out);
1479 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1482 return Processor::configure_io (in, out);
1485 /** Decide whether this PluginInsert can support a given IO configuration.
1486 * To do this, we run through a set of possible solutions in rough order of
1489 * @param in Required input channel count.
1490 * @param out Filled in with the output channel count if we return true.
1491 * @return true if the given IO configuration can be supported.
1494 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1497 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1499 return private_can_support_io_configuration (in, out).method != Impossible;
1502 /** A private version of can_support_io_configuration which returns the method
1503 * by which the configuration can be matched, rather than just whether or not
1507 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1509 if (_plugins.empty()) {
1514 if (is_channelstrip ()) {
1516 return Match (ExactMatch, 1);
1520 /* if a user specified a custom cfg, so be it. */
1523 return Match (ExactMatch, get_count(), _strict_io, true); // XXX
1526 /* try automatic configuration */
1527 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1529 PluginInfoPtr info = _plugins.front()->get_info();
1530 ChanCount inputs = info->n_inputs;
1531 ChanCount outputs = info->n_outputs;
1533 /* handle case strict-i/o */
1534 if (_strict_io && m.method != Impossible) {
1537 /* special case MIDI instruments */
1538 if (is_midi_instrument()) {
1539 // output = midi-bypass + at most master-out channels.
1540 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1541 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1542 out = ChanCount::min (out, max_out);
1543 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o instrument: %1\n", name()));
1549 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1550 /* replicate processor to match output count (generators and such)
1551 * at least enough to feed every output port. */
1552 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1553 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1554 uint32_t nout = outputs.get (*t);
1555 if (nout == 0 || inx.get(*t) == 0) { continue; }
1556 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1559 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o generator: %1\n", name()));
1560 return Match (Replicate, f, _strict_io);
1571 if (m.method != Impossible) {
1575 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1577 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
1579 if (info->reconfigurable_io()) {
1581 // TODO add sidechains here
1582 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1584 // houston, we have a problem.
1585 return Match (Impossible, 0);
1587 return Match (Delegate, 1, _strict_io);
1590 ChanCount midi_bypass;
1591 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1592 midi_bypass.set (DataType::MIDI, 1);
1595 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1597 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1598 uint32_t nin = ns_inputs.get (*t);
1599 uint32_t nout = outputs.get (*t);
1600 if (nin == 0 || inx.get(*t) == 0) { continue; }
1601 // prefer floor() so the count won't overly increase IFF (nin < nout)
1602 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1604 if (f > 0 && outputs * f >= _configured_out) {
1605 out = outputs * f + midi_bypass;
1606 return Match (Replicate, f, _strict_io);
1609 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1611 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1612 uint32_t nin = ns_inputs.get (*t);
1613 if (nin == 0 || inx.get(*t) == 0) { continue; }
1614 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1617 out = outputs * f + midi_bypass;
1618 return Match (Replicate, f, _strict_io);
1621 // add at least as many plugins needed to connect all inputs
1623 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1624 uint32_t nin = inputs.get (*t);
1625 if (nin == 0 || inx.get(*t) == 0) { continue; }
1626 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1628 out = outputs * f + midi_bypass;
1629 return Match (Replicate, f, _strict_io);
1632 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1634 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1636 if (_plugins.empty()) {
1640 PluginInfoPtr info = _plugins.front()->get_info();
1641 ChanCount in; in += inx;
1642 ChanCount midi_bypass;
1644 if (info->reconfigurable_io()) {
1645 /* Plugin has flexible I/O, so delegate to it */
1646 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1648 return Match (Impossible, 0);
1650 return Match (Delegate, 1);
1653 ChanCount inputs = info->n_inputs;
1654 ChanCount outputs = info->n_outputs;
1655 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1657 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1658 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1659 midi_bypass.set (DataType::MIDI, 1);
1661 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1662 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1663 in.set(DataType::MIDI, 0);
1666 // add internally provided sidechain ports
1667 ChanCount insc = in + sidechain_input_ports ();
1669 bool no_inputs = true;
1670 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1671 if (inputs.get (*t) != 0) {
1678 /* no inputs so we can take any input configuration since we throw it away */
1679 out = outputs + midi_bypass;
1680 return Match (NoInputs, 1);
1683 /* Plugin inputs match requested inputs + side-chain-ports exactly */
1684 if (inputs == insc) {
1685 out = outputs + midi_bypass;
1686 return Match (ExactMatch, 1);
1689 /* Plugin inputs matches without side-chain-pins */
1690 if (ns_inputs == in) {
1691 out = outputs + midi_bypass;
1692 return Match (ExactMatch, 1);
1695 /* We may be able to run more than one copy of the plugin within this insert
1696 to cope with the insert having more inputs than the plugin.
1697 We allow replication only for plugins with either zero or 1 inputs and outputs
1698 for every valid data type.
1702 bool can_replicate = true;
1703 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
1705 // ignore side-chains
1706 uint32_t nin = ns_inputs.get (*t);
1708 // No inputs of this type
1709 if (nin == 0 && in.get(*t) == 0) {
1713 if (nin != 1 || outputs.get (*t) != 1) {
1714 can_replicate = false;
1718 // Potential factor not set yet
1720 f = in.get(*t) / nin;
1723 // Factor for this type does not match another type, can not replicate
1724 if (f != (in.get(*t) / nin)) {
1725 can_replicate = false;
1730 if (can_replicate && f > 0) {
1731 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1732 out.set (*t, outputs.get(*t) * f);
1735 return Match (Replicate, f);
1738 /* If the processor has exactly one input of a given type, and
1739 the plugin has more, we can feed the single processor input
1740 to some or all of the plugin inputs. This is rather
1741 special-case-y, but the 1-to-many case is by far the
1742 simplest. How do I split thy 2 processor inputs to 3
1743 plugin inputs? Let me count the ways ...
1746 bool can_split = true;
1747 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1749 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
1750 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1752 if (!can_split_type && !nothing_to_do_for_type) {
1758 out = outputs + midi_bypass;
1759 return Match (Split, 1);
1762 /* If the plugin has more inputs than we want, we can `hide' some of them
1763 by feeding them silence.
1766 bool could_hide = false;
1767 bool cannot_hide = false;
1768 ChanCount hide_channels;
1770 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1771 if (inputs.get(*t) > in.get(*t)) {
1772 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1773 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1775 } else if (inputs.get(*t) < in.get(*t)) {
1776 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1781 if (could_hide && !cannot_hide) {
1782 out = outputs + midi_bypass;
1783 return Match (Hide, 1, false, false, hide_channels);
1786 return Match (Impossible, 0);
1791 PluginInsert::get_state ()
1793 return state (true);
1797 PluginInsert::state (bool full)
1799 XMLNode& node = Processor::state (full);
1801 node.add_property("type", _plugins[0]->state_node_name());
1802 node.add_property("unique-id", _plugins[0]->unique_id());
1803 node.add_property("count", string_compose("%1", _plugins.size()));
1805 /* remember actual i/o configuration (for later placeholder
1806 * in case the plugin goes missing) */
1807 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1808 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1810 /* save custom i/o config */
1811 node.add_property("custom", _custom_cfg ? "yes" : "no");
1812 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1814 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1815 node.add_child_nocopy (* _in_map[pc].state (tmp));
1816 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1817 node.add_child_nocopy (* _out_map[pc].state (tmp));
1819 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
1822 node.add_child_nocopy (_sidechain->state (full));
1825 _plugins[0]->set_insert_id(this->id());
1826 node.add_child_nocopy (_plugins[0]->get_state());
1828 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1829 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1831 node.add_child_nocopy (ac->get_state());
1839 PluginInsert::set_control_ids (const XMLNode& node, int version)
1841 const XMLNodeList& nlist = node.children();
1842 XMLNodeConstIterator iter;
1843 set<Evoral::Parameter>::const_iterator p;
1845 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1846 if ((*iter)->name() == Controllable::xml_node_name) {
1847 const XMLProperty* prop;
1849 uint32_t p = (uint32_t)-1;
1851 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1852 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1854 p = lv2plugin->port_index(prop->value().c_str());
1858 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1859 p = atoi (prop->value());
1862 if (p != (uint32_t)-1) {
1864 /* this may create the new controllable */
1866 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1868 #ifndef NO_PLUGIN_STATE
1872 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1874 ac->set_state (**iter, version);
1883 PluginInsert::set_state(const XMLNode& node, int version)
1885 XMLNodeList nlist = node.children();
1886 XMLNodeIterator niter;
1887 XMLPropertyList plist;
1888 const XMLProperty *prop;
1889 ARDOUR::PluginType type;
1891 if ((prop = node.property ("type")) == 0) {
1892 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1896 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1897 type = ARDOUR::LADSPA;
1898 } else if (prop->value() == X_("lv2")) {
1900 } else if (prop->value() == X_("windows-vst")) {
1901 type = ARDOUR::Windows_VST;
1902 } else if (prop->value() == X_("lxvst")) {
1903 type = ARDOUR::LXVST;
1904 } else if (prop->value() == X_("audiounit")) {
1905 type = ARDOUR::AudioUnit;
1906 } else if (prop->value() == X_("luaproc")) {
1909 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1915 prop = node.property ("unique-id");
1918 #ifdef WINDOWS_VST_SUPPORT
1919 /* older sessions contain VST plugins with only an "id" field.
1922 if (type == ARDOUR::Windows_VST) {
1923 prop = node.property ("id");
1927 #ifdef LXVST_SUPPORT
1928 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1930 if (type == ARDOUR::LXVST) {
1931 prop = node.property ("id");
1937 error << _("Plugin has no unique ID field") << endmsg;
1942 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1944 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1945 * allow to move sessions windows <> linux */
1946 #ifdef LXVST_SUPPORT
1947 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1948 type = ARDOUR::LXVST;
1949 plugin = find_plugin (_session, prop->value(), type);
1953 #ifdef WINDOWS_VST_SUPPORT
1954 if (plugin == 0 && type == ARDOUR::LXVST) {
1955 type = ARDOUR::Windows_VST;
1956 plugin = find_plugin (_session, prop->value(), type);
1961 error << string_compose(
1962 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1963 "Perhaps it was removed or moved since it was last used."),
1969 if (type == ARDOUR::Lua) {
1970 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1971 // we need to load the script to set the name and parameters.
1972 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1974 lp->set_script_from_state (*ls);
1978 // The name of the PluginInsert comes from the plugin, nothing else
1979 _name = plugin->get_info()->name;
1983 // Processor::set_state() will set this, but too late
1984 // for it to be available when setting up plugin
1985 // state. We can't call Processor::set_state() until
1986 // the plugins themselves are created and added.
1990 if (_plugins.empty()) {
1991 /* if we are adding the first plugin, we will need to set
1992 up automatable controls.
1994 add_plugin (plugin);
1995 create_automatable_parameters ();
1996 set_control_ids (node, version);
1999 if ((prop = node.property ("count")) != 0) {
2000 sscanf (prop->value().c_str(), "%u", &count);
2003 if (_plugins.size() != count) {
2004 for (uint32_t n = 1; n < count; ++n) {
2005 add_plugin (plugin_factory (plugin));
2009 Processor::set_state (node, version);
2011 PBD::ID new_id = this->id();
2012 PBD::ID old_id = this->id();
2014 if ((prop = node.property ("id")) != 0) {
2015 old_id = prop->value ();
2018 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2020 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2021 and set all plugins to the same state.
2024 if ((*niter)->name() == plugin->state_node_name()) {
2026 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2027 /* Plugin state can include external files which are named after the ID.
2029 * If regenerate_xml_or_string_ids() is set, the ID will already have
2030 * been changed, so we need to use the old ID from the XML to load the
2031 * state and then update the ID.
2033 * When copying a plugin-state, route_ui takes care of of updating the ID,
2034 * but we need to call set_insert_id() to clear the cached plugin-state
2035 * and force a change.
2037 if (!regenerate_xml_or_string_ids ()) {
2038 (*i)->set_insert_id (new_id);
2040 (*i)->set_insert_id (old_id);
2043 (*i)->set_state (**niter, version);
2045 if (regenerate_xml_or_string_ids ()) {
2046 (*i)->set_insert_id (new_id);
2054 if (version < 3000) {
2056 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2057 this is all handled by Automatable
2060 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2061 if ((*niter)->name() == "Redirect") {
2062 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2063 Processor::set_state (**niter, version);
2068 set_parameter_state_2X (node, version);
2071 if ((prop = node.property (X_("custom"))) != 0) {
2072 _custom_cfg = string_is_affirmative (prop->value());
2075 uint32_t in_maps = 0;
2076 uint32_t out_maps = 0;
2077 XMLNodeList kids = node.children ();
2078 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2079 if ((*i)->name() == X_("ConfiguredOutput")) {
2080 _custom_out = ChanCount(**i);
2082 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2083 long pc = atol (&((*i)->name().c_str()[9]));
2084 if (pc >=0 && pc <= get_count()) {
2085 _in_map[pc] = ChanMapping (**i);
2089 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2090 long pc = atol (&((*i)->name().c_str()[10]));
2091 if (pc >=0 && pc <= get_count()) {
2092 _out_map[pc] = ChanMapping (**i);
2096 if ((*i)->name () == "ThruMap") {
2097 _thru_map = ChanMapping (**i);
2100 // sidechain is a Processor (IO)
2101 if ((*i)->name () == Processor::state_node_name) {
2105 _sidechain->set_state (**i, version);
2109 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2110 _maps_from_state = true;
2113 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2117 (*i)->deactivate ();
2121 PluginConfigChanged (); /* EMIT SIGNAL */
2126 PluginInsert::update_id (PBD::ID id)
2129 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2130 (*i)->set_insert_id (id);
2135 PluginInsert::set_state_dir (const std::string& d)
2137 // state() only saves the state of the first plugin
2138 _plugins[0]->set_state_dir (d);
2142 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2144 XMLNodeList nlist = node.children();
2145 XMLNodeIterator niter;
2147 /* look for port automation node */
2149 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2151 if ((*niter)->name() != port_automation_node_name) {
2157 XMLNodeConstIterator iter;
2162 cnodes = (*niter)->children ("port");
2164 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2168 if ((cprop = child->property("number")) != 0) {
2169 port = cprop->value().c_str();
2171 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2175 sscanf (port, "%" PRIu32, &port_id);
2177 if (port_id >= _plugins[0]->parameter_count()) {
2178 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2182 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2183 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2185 if (c && c->alist()) {
2186 if (!child->children().empty()) {
2187 c->alist()->set_state (*child->children().front(), version);
2189 /* In some cases 2.X saves lists with min_yval and max_yval
2190 being FLT_MIN and FLT_MAX respectively. This causes problems
2191 in A3 because these min/max values are used to compute
2192 where GUI control points should be drawn. If we see such
2193 values, `correct' them to the min/max of the appropriate
2197 float min_y = c->alist()->get_min_y ();
2198 float max_y = c->alist()->get_max_y ();
2200 ParameterDescriptor desc;
2201 _plugins.front()->get_parameter_descriptor (port_id, desc);
2203 if (min_y == FLT_MIN) {
2207 if (max_y == FLT_MAX) {
2211 c->alist()->set_yrange (min_y, max_y);
2214 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2226 PluginInsert::describe_parameter (Evoral::Parameter param)
2228 if (param.type() == PluginAutomation) {
2229 return _plugins[0]->describe_parameter (param);
2230 } else if (param.type() == PluginPropertyAutomation) {
2231 boost::shared_ptr<AutomationControl> c(automation_control(param));
2232 if (c && !c->desc().label.empty()) {
2233 return c->desc().label;
2236 return Automatable::describe_parameter(param);
2240 PluginInsert::signal_latency() const
2242 if (_user_latency) {
2243 return _user_latency;
2246 return _plugins[0]->signal_latency ();
2250 PluginInsert::type ()
2252 return plugin()->get_info()->type;
2255 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2256 const Evoral::Parameter& param,
2257 const ParameterDescriptor& desc,
2258 boost::shared_ptr<AutomationList> list)
2259 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2263 alist()->reset_default (desc.normal);
2265 list->set_interpolation(Evoral::ControlList::Discrete);
2270 set_flags(Controllable::Toggle);
2274 /** @param val `user' value */
2276 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2279 _set_value (user_val, group_override);
2283 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2285 /* used only by automation playback */
2286 _set_value (user_val, Controllable::NoGroup);
2290 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2292 /* FIXME: probably should be taking out some lock here.. */
2294 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2295 (*i)->set_parameter (_list->parameter().id(), user_val);
2298 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2300 iasp->set_parameter (_list->parameter().id(), user_val);
2303 AutomationControl::set_value (user_val, group_override);
2307 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2309 AutomationControl::set_value (user_val, Controllable::NoGroup);
2313 PluginInsert::PluginControl::get_state ()
2317 XMLNode& node (AutomationControl::get_state());
2318 ss << parameter().id();
2319 node.add_property (X_("parameter"), ss.str());
2321 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2323 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2330 /** @return `user' val */
2332 PluginInsert::PluginControl::get_value () const
2334 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2340 return plugin->get_parameter (_list->parameter().id());
2343 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2344 const Evoral::Parameter& param,
2345 const ParameterDescriptor& desc,
2346 boost::shared_ptr<AutomationList> list)
2347 : AutomationControl (p->session(), param, desc, list)
2351 alist()->set_yrange (desc.lower, desc.upper);
2352 alist()->reset_default (desc.normal);
2356 set_flags(Controllable::Toggle);
2361 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2364 set_value_unchecked (user_val);
2369 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2371 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2372 This is lossy, but better than nothing until Ardour's automation system
2373 can handle various datatypes all the way down. */
2374 const Variant value(_desc.datatype, user_val);
2375 if (value.type() == Variant::NOTHING) {
2376 error << "set_value(double) called for non-numeric property" << endmsg;
2380 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2381 (*i)->set_property(_list->parameter().id(), value);
2385 AutomationControl::set_value (user_val, Controllable::NoGroup);
2389 PluginInsert::PluginPropertyControl::get_state ()
2393 XMLNode& node (AutomationControl::get_state());
2394 ss << parameter().id();
2395 node.add_property (X_("property"), ss.str());
2396 node.remove_property (X_("value"));
2402 PluginInsert::PluginPropertyControl::get_value () const
2404 return _value.to_double();
2407 boost::shared_ptr<Plugin>
2408 PluginInsert::get_impulse_analysis_plugin()
2410 boost::shared_ptr<Plugin> ret;
2411 if (_impulseAnalysisPlugin.expired()) {
2412 ret = plugin_factory(_plugins[0]);
2413 ret->configure_io (internal_input_streams (), internal_output_streams ());
2414 _impulseAnalysisPlugin = ret;
2416 ret = _impulseAnalysisPlugin.lock();
2423 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2425 // called from outside the audio thread, so this should be safe
2426 // only do audio as analysis is (currently) only for audio plugins
2427 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, internal_input_streams().n_audio(), nframes);
2428 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2430 _signal_analysis_collected_nframes = 0;
2431 _signal_analysis_collect_nframes_max = nframes;
2434 /** Add a plugin to our list */
2436 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2438 plugin->set_insert_id (this->id());
2440 if (_plugins.empty()) {
2441 /* first (and probably only) plugin instance - connect to relevant signals */
2443 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2444 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2445 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2446 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2447 // cache sidechain port count
2448 _cached_sidechain_pins.reset ();
2449 const ChanCount& nis (plugin->get_info()->n_inputs);
2450 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2451 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2452 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2453 if (iod.is_sidechain) {
2454 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2459 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2460 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2462 vst->set_insert (this, _plugins.size ());
2465 _plugins.push_back (plugin);
2469 PluginInsert::realtime_handle_transport_stopped ()
2471 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2472 (*i)->realtime_handle_transport_stopped ();
2477 PluginInsert::realtime_locate ()
2479 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2480 (*i)->realtime_locate ();
2485 PluginInsert::monitoring_changed ()
2487 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2488 (*i)->monitoring_changed ();
2493 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2495 // this is called in RT context, LatencyChanged is emitted after run()
2496 _latency_changed = true;
2500 PluginInsert::start_touch (uint32_t param_id)
2502 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2504 ac->start_touch (session().audible_frame());
2509 PluginInsert::end_touch (uint32_t param_id)
2511 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2513 ac->stop_touch (true, session().audible_frame());
2517 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2520 case PluginInsert::Impossible: o << "Impossible"; break;
2521 case PluginInsert::Delegate: o << "Delegate"; break;
2522 case PluginInsert::NoInputs: o << "NoInputs"; break;
2523 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2524 case PluginInsert::Replicate: o << "Replicate"; break;
2525 case PluginInsert::Split: o << "Split"; break;
2526 case PluginInsert::Hide: o << "Hide"; break;
2528 o << " cnt: " << m.plugins
2529 << (m.strict_io ? " strict-io" : "")
2530 << (m.custom_cfg ? " custom-cfg" : "");
2531 if (m.method == PluginInsert::Hide) {
2532 o << " hide: " << m.hide;