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_total () > 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 // TODO add route-name, plugin name and shorten.. (plugin name can be long and conatain odd chars)
170 std::string n = "Sidechain " + id().to_s(); /// XXX
171 SideChain *sc = new SideChain (_session, n);
172 _sidechain = boost::shared_ptr<SideChain> (sc);
173 _sidechain->activate ();
174 for (uint32_t n = 0; n < n_audio; ++n) {
175 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
177 PluginConfigChanged (); /* EMIT SIGNAL */
182 PluginInsert::del_sidechain ()
188 PluginConfigChanged (); /* EMIT SIGNAL */
193 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
195 if (which.type() != PluginAutomation)
198 boost::shared_ptr<AutomationControl> c
199 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
202 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
207 PluginInsert::output_streams() const
209 assert (_configured);
210 return _configured_out;
214 PluginInsert::input_streams() const
216 assert (_configured);
217 return _configured_in;
221 PluginInsert::internal_streams() const
223 assert (_configured);
224 return _configured_internal;
228 PluginInsert::internal_output_streams() const
230 assert (!_plugins.empty());
232 PluginInfoPtr info = _plugins.front()->get_info();
234 if (info->reconfigurable_io()) {
235 ChanCount out = _plugins.front()->output_streams ();
236 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
239 ChanCount out = info->n_outputs;
240 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
241 out.set_audio (out.n_audio() * _plugins.size());
242 out.set_midi (out.n_midi() * _plugins.size());
248 PluginInsert::internal_input_streams() const
250 assert (!_plugins.empty());
254 PluginInfoPtr info = _plugins.front()->get_info();
256 if (info->reconfigurable_io()) {
257 assert (_plugins.size() == 1);
258 in = _plugins.front()->input_streams();
263 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
265 if (_match.method == Split) {
267 /* we are splitting 1 processor input to multiple plugin inputs,
268 so we have a maximum of 1 stream of each type.
270 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
271 if (in.get (*t) > 1) {
277 } else if (_match.method == Hide) {
279 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
280 in.set (*t, in.get (*t) - _match.hide.get (*t));
286 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
287 in.set (*t, in.get (*t) * _plugins.size ());
295 PluginInsert::natural_output_streams() const
298 if (is_channelstrip ()) {
299 return _configured_out;
302 return _plugins[0]->get_info()->n_outputs;
306 PluginInsert::natural_input_streams() const
309 if (is_channelstrip ()) {
310 return _configured_in;
313 return _plugins[0]->get_info()->n_inputs;
317 PluginInsert::sidechain_input_pins() const
319 return _cached_sidechain_pins;
323 PluginInsert::has_no_inputs() const
325 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
329 PluginInsert::has_no_audio_inputs() const
331 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
335 PluginInsert::is_midi_instrument() const
337 /* XXX more finesse is possible here. VST plugins have a
338 a specific "instrument" flag, for example.
340 PluginInfoPtr pi = _plugins[0]->get_info();
342 return pi->n_inputs.n_midi() != 0 &&
343 pi->n_outputs.n_audio() > 0;
347 PluginInsert::create_automatable_parameters ()
349 assert (!_plugins.empty());
351 set<Evoral::Parameter> a = _plugins.front()->automatable ();
353 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
354 if (i->type() == PluginAutomation) {
356 Evoral::Parameter param(*i);
358 ParameterDescriptor desc;
359 _plugins.front()->get_parameter_descriptor(i->id(), desc);
361 can_automate (param);
362 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
363 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
365 _plugins.front()->set_automation_control (i->id(), c);
366 } else if (i->type() == PluginPropertyAutomation) {
367 Evoral::Parameter param(*i);
368 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
369 if (desc.datatype != Variant::NOTHING) {
370 boost::shared_ptr<AutomationList> list;
371 if (Variant::type_is_numeric(desc.datatype)) {
372 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
374 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
379 /** Called when something outside of this host has modified a plugin
380 * parameter. Responsible for propagating the change to two places:
382 * 1) anything listening to the Control itself
383 * 2) any replicated plugins that make up this PluginInsert.
385 * The PluginInsert is connected to the ParameterChangedExternally signal for
386 * the first (primary) plugin, and here broadcasts that change to any others.
388 * XXX We should probably drop this whole replication idea (Paul, October 2015)
389 * since it isn't used by sensible plugin APIs (AU, LV2).
392 PluginInsert::parameter_changed_externally (uint32_t which, float val)
394 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
396 /* First propagation: alter the underlying value of the control,
397 * without telling the plugin(s) that own/use it to set it.
404 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
407 pc->catch_up_with_external_value (val);
410 /* Second propagation: tell all plugins except the first to
411 update the value of this parameter. For sane plugin APIs,
412 there are no other plugins, so this is a no-op in those
416 Plugins::iterator i = _plugins.begin();
418 /* don't set the first plugin, just all the slaves */
420 if (i != _plugins.end()) {
422 for (; i != _plugins.end(); ++i) {
423 (*i)->set_parameter (which, val);
429 PluginInsert::set_block_size (pframes_t nframes)
432 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
433 if ((*i)->set_block_size (nframes) != 0) {
441 PluginInsert::activate ()
443 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
447 Processor::activate ();
451 PluginInsert::deactivate ()
453 Processor::deactivate ();
455 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
461 PluginInsert::flush ()
463 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
469 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
471 // TODO: atomically copy maps & _no_inplace
472 PinMappings in_map (_in_map);
473 PinMappings out_map (_out_map);
474 ChanMapping thru_map (_thru_map);
475 if (_mapping_changed) {
476 _no_inplace = check_inplace ();
477 _mapping_changed = false;
480 if (_match.method == Split && !_no_inplace) {
481 // TODO: also use this optimization if one source-buffer
482 // feeds _all_ *connected* inputs.
483 // currently this is *first* buffer to all only --
484 // see PluginInsert::check_inplace
485 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
486 if (_configured_internal.get (*t) == 0) {
490 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
491 assert (valid && first_idx == 0); // check_inplace ensures this
492 /* copy the first stream's buffer contents to the others */
493 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
494 uint32_t idx = in_map[0].get (*t, i, &valid);
497 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
501 /* the copy operation produces a linear monotonic input map */
502 in_map[0] = ChanMapping (natural_input_streams ());
505 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
506 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
512 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
514 boost::shared_ptr<AutomationControl> c
515 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
517 if (c->list() && c->automation_playback()) {
520 const float val = c->list()->rt_safe_eval (now, valid);
523 /* This is the ONLY place where we are
525 * AutomationControl::set_value_unchecked(). We
526 * know that the control is in
527 * automation playback mode, so no
528 * check on writable() is required
529 * (which must be done in AutomationControl::set_value()
532 c->set_value_unchecked(val);
539 /* Calculate if, and how many frames we need to collect for analysis */
540 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
541 _signal_analysis_collected_nframes);
542 if (nframes < collect_signal_nframes) { // we might not get all frames now
543 collect_signal_nframes = nframes;
546 if (collect_signal_nframes > 0) {
548 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
549 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
550 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
552 _signal_analysis_inputs.set_count(internal_input_streams());
554 for (uint32_t i = 0; i < internal_input_streams().n_audio(); ++i) {
555 _signal_analysis_inputs.get_audio(i).read_from(
557 collect_signal_nframes,
558 _signal_analysis_collected_nframes); // offset is for target buffer
563 if (is_channelstrip ()) {
564 if (_configured_in.n_audio() > 0) {
565 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
566 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
568 _plugins.front()->connect_and_run (bufs, mb_in_map, mb_out_map, nframes, offset);
570 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
571 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
577 // TODO optimize -- build maps once.
579 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
580 ARDOUR::ChanMapping used_outputs;
582 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
584 /* build used-output map */
585 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
586 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
587 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
589 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
591 used_outputs.set (*t, out_idx, 1); // mark as used
596 /* copy thru data to outputs before processing in-place */
597 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
598 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
600 uint32_t in_idx = thru_map.get (*t, out, &valid);
602 uint32_t m = out + natural_input_streams ().get (*t);
603 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
604 used_outputs.set (*t, out, 1); // mark as used
610 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
612 ARDOUR::ChanMapping i_in_map (natural_input_streams());
613 ARDOUR::ChanMapping i_out_map (out_map[pc]);
614 ARDOUR::ChanCount mapped;
616 /* map inputs sequentially */
617 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
618 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
620 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
621 uint32_t m = mapped.get (*t);
623 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
625 inplace_bufs.get (*t, m).silence (nframes, offset);
627 mapped.set (*t, m + 1);
631 /* outputs are mapped to inplace_bufs after the inputs */
632 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
633 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
636 if ((*i)->connect_and_run (inplace_bufs, i_in_map, i_out_map, nframes, offset)) {
641 /* all instances have completed, now copy data that was written
642 * and zero unconnected buffers */
643 ARDOUR::ChanMapping nonzero_out (used_outputs);
644 if (has_midi_bypass ()) {
645 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
647 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
648 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
650 used_outputs.get (*t, out, &valid);
652 nonzero_out.get (*t, out, &valid);
654 bufs.get (*t, out).silence (nframes, offset);
657 uint32_t m = out + natural_input_streams ().get (*t);
658 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
663 /* in-place processing */
665 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
666 if ((*i)->connect_and_run(bufs, in_map[pc], out_map[pc], nframes, offset)) {
671 // TODO optimize: store "unconnected" in a fixed set.
672 // it only changes on reconfiguration.
673 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
674 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
676 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
677 mapped = true; // in-place Midi bypass
679 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
680 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
682 uint32_t idx = out_map[pc].get (*t, o, &valid);
683 if (valid && idx == out) {
690 bufs.get (*t, out).silence (nframes, offset);
696 if (collect_signal_nframes > 0) {
698 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
699 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
701 _signal_analysis_outputs.set_count(internal_output_streams());
703 for (uint32_t i = 0; i < internal_output_streams().n_audio(); ++i) {
704 _signal_analysis_outputs.get_audio(i).read_from(
706 collect_signal_nframes,
707 _signal_analysis_collected_nframes); // offset is for target buffer
710 _signal_analysis_collected_nframes += collect_signal_nframes;
711 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
713 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
714 _signal_analysis_collect_nframes_max = 0;
715 _signal_analysis_collected_nframes = 0;
717 AnalysisDataGathered(&_signal_analysis_inputs,
718 &_signal_analysis_outputs);
724 PluginInsert::silence (framecnt_t nframes)
730 ChanMapping in_map (natural_input_streams ());
731 ChanMapping out_map (natural_output_streams ());
733 // TODO run sidechain (delaylines)
734 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
735 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
740 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
742 if (_pending_active) {
743 /* run as normal if we are active or moving from inactive to active */
746 // collect sidechain input for complete cycle (!)
747 // TODO we need delaylines here for latency compensation
748 _sidechain->run (bufs, start_frame, end_frame, nframes, true);
751 if (_session.transport_rolling() || _session.bounce_processing()) {
752 automation_run (bufs, start_frame, nframes);
754 connect_and_run (bufs, nframes, 0, false);
758 // TODO use mapping in bypassed mode ?!
759 // -> do we bypass the processor or the plugin
761 // TODO include sidechain??
763 uint32_t in = input_streams ().n_audio ();
764 uint32_t out = output_streams().n_audio ();
766 if (has_no_audio_inputs() || in == 0) {
768 /* silence all (audio) outputs. Should really declick
769 * at the transitions of "active"
772 for (uint32_t n = 0; n < out; ++n) {
773 bufs.get_audio (n).silence (nframes);
776 } else if (out > in) {
778 /* not active, but something has make up for any channel count increase
779 * for now , simply replicate last buffer
781 for (uint32_t n = in; n < out; ++n) {
782 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
786 bufs.count().set_audio (out);
789 _active = _pending_active;
791 /* we have no idea whether the plugin generated silence or not, so mark
792 * all buffers appropriately.
797 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
799 Evoral::ControlEvent next_event (0, 0.0f);
800 framepos_t now = start;
801 framepos_t end = now + nframes;
802 framecnt_t offset = 0;
804 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
807 connect_and_run (bufs, nframes, offset, false);
811 if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
813 /* no events have a time within the relevant range */
815 connect_and_run (bufs, nframes, offset, true, now);
821 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
823 connect_and_run (bufs, cnt, offset, true, now);
829 if (!find_next_event (now, end, next_event)) {
834 /* cleanup anything that is left to do */
837 connect_and_run (bufs, nframes, offset, true, now);
842 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
844 if (param.type() != PluginAutomation)
847 if (_plugins.empty()) {
848 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
850 abort(); /*NOTREACHED*/
853 return _plugins[0]->default_value (param.id());
858 PluginInsert::can_reset_all_parameters ()
862 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
864 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
866 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
870 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
876 if (ac->automation_state() & Play) {
881 return all && (params > 0);
885 PluginInsert::reset_parameters_to_default ()
889 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
891 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
893 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
897 const float dflt = _plugins[0]->default_value (cid);
898 const float curr = _plugins[0]->get_parameter (cid);
904 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
909 if (ac->automation_state() & Play) {
914 ac->set_value (dflt, Controllable::NoGroup);
919 boost::shared_ptr<Plugin>
920 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
922 boost::shared_ptr<LadspaPlugin> lp;
923 boost::shared_ptr<LuaProc> lua;
925 boost::shared_ptr<LV2Plugin> lv2p;
927 #ifdef WINDOWS_VST_SUPPORT
928 boost::shared_ptr<WindowsVSTPlugin> vp;
931 boost::shared_ptr<LXVSTPlugin> lxvp;
933 #ifdef AUDIOUNIT_SUPPORT
934 boost::shared_ptr<AUPlugin> ap;
937 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
938 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
939 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
940 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
942 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
943 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
945 #ifdef WINDOWS_VST_SUPPORT
946 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
947 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
950 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
951 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
953 #ifdef AUDIOUNIT_SUPPORT
954 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
955 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
959 fatal << string_compose (_("programming error: %1"),
960 X_("unknown plugin type in PluginInsert::plugin_factory"))
962 abort(); /*NOTREACHED*/
963 return boost::shared_ptr<Plugin> ((Plugin*) 0);
967 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
968 if (num < _in_map.size()) {
969 bool changed = _in_map[num] != m;
971 changed |= sanitize_maps ();
973 PluginMapChanged (); /* EMIT SIGNAL */
974 _mapping_changed = true;
975 _session.set_dirty();
981 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
982 if (num < _out_map.size()) {
983 bool changed = _out_map[num] != m;
985 changed |= sanitize_maps ();
987 PluginMapChanged (); /* EMIT SIGNAL */
988 _mapping_changed = true;
989 _session.set_dirty();
995 PluginInsert::set_thru_map (ChanMapping m) {
996 bool changed = _thru_map != m;
998 changed |= sanitize_maps ();
1000 PluginMapChanged (); /* EMIT SIGNAL */
1001 _mapping_changed = true;
1002 _session.set_dirty();
1007 PluginInsert::input_map () const
1011 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1012 ChanMapping m (i->second);
1013 const ChanMapping::Mappings& mp ((*i).second.mappings());
1014 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1015 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1016 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1024 PluginInsert::output_map () const
1028 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1029 ChanMapping m (i->second);
1030 const ChanMapping::Mappings& mp ((*i).second.mappings());
1031 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1032 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1033 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1037 if (has_midi_bypass ()) {
1038 rv.set (DataType::MIDI, 0, 0);
1045 PluginInsert::has_midi_bypass () const
1047 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1048 && natural_output_streams ().n_midi () == 0) {
1055 PluginInsert::has_midi_thru () const
1057 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1058 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1066 PluginInsert::is_channelstrip () const {
1067 return _plugins.front()->is_channelstrip();
1072 PluginInsert::check_inplace ()
1074 bool inplace_ok = !_plugins.front()->inplace_broken ();
1076 if (_thru_map.count () > 0) {
1077 // TODO once midi-bypass is part of the mapping, ignore it
1081 if (_match.method == Split && inplace_ok) {
1082 assert (get_count() == 1);
1083 assert (_in_map.size () == 1);
1084 if (!_out_map[0].is_monotonic ()) {
1087 if (_configured_internal != _configured_in) {
1088 /* no sidechain -- TODO we could allow this with
1089 * some more logic in PluginInsert::connect_and_run().
1091 * PluginInsert::reset_map() already maps it.
1096 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1097 if (_configured_internal.get (*t) == 0) {
1101 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1102 if (!valid || first_idx != 0) {
1103 // so far only allow to copy the *first* stream's buffer to others
1106 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1107 uint32_t idx = _in_map[0].get (*t, i, &valid);
1108 if (valid && idx != first_idx) {
1117 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1122 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1123 if (!_in_map[pc].is_monotonic ()) {
1126 if (!_out_map[pc].is_monotonic ()) {
1130 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1131 return !inplace_ok; // no-inplace
1135 PluginInsert::sanitize_maps ()
1137 bool changed = false;
1138 /* strip dead wood */
1139 PinMappings new_ins;
1140 PinMappings new_outs;
1141 ChanMapping new_thru (_thru_map);
1143 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1145 ChanMapping new_out;
1146 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1147 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1149 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1150 if (valid && idx < _configured_internal.get (*t)) {
1151 new_in.set (*t, i, idx);
1154 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1156 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1157 if (valid && idx < _configured_out.get (*t)) {
1158 new_out.set (*t, o, idx);
1162 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1165 new_ins[pc] = new_in;
1166 new_outs[pc] = new_out;
1169 /* prevent dup output assignments */
1170 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1171 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1172 bool mapped = false;
1173 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1175 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1176 if (valid && mapped) {
1177 new_outs[pc].unset (*t, idx);
1185 /* prevent out + thru, existing plugin outputs override thru */
1186 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1187 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1188 bool mapped = false;
1190 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1191 new_outs[pc].get_src (*t, o, &mapped);
1192 if (mapped) { break; }
1194 if (!mapped) { continue; }
1195 uint32_t idx = new_thru.get (*t, o, &valid);
1197 new_thru.unset (*t, idx);
1202 if (has_midi_bypass ()) {
1203 // TODO: include midi-bypass in the thru set,
1204 // remove dedicated handling.
1205 new_thru.unset (DataType::MIDI, 0);
1208 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1212 _out_map = new_outs;
1213 _thru_map = new_thru;
1219 PluginInsert::reset_map (bool emit)
1222 const PinMappings old_in (_in_map);
1223 const PinMappings old_out (_out_map);
1227 _thru_map = ChanMapping ();
1228 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1229 ChanCount ns_inputs = natural_input_streams() - sidechain_input_pins ();
1230 if (_match.method == Split) {
1231 _in_map[pc] = ChanMapping ();
1232 /* connect no sidechain sinks in round-robin fashion */
1233 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1234 const uint32_t cend = _configured_in.get (*t);
1235 if (cend == 0) { continue; }
1237 for (uint32_t in = 0; in < ns_inputs.get (*t); ++in) {
1238 _in_map[pc].set (*t, in, c);
1243 _in_map[pc] = ChanMapping (ChanCount::min (ns_inputs, _configured_in));
1245 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1247 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1248 const uint32_t nis = natural_input_streams ().get(*t);
1249 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1250 _in_map[pc].offset_to(*t, stride * pc);
1251 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1253 // connect side-chains
1254 const uint32_t sc_start = _configured_in.get (*t);
1255 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1256 if (sc_len == 0) { continue; }
1258 for (uint32_t in = ns_inputs.get (*t); in < nis; ++in) {
1259 _in_map[pc].set (*t, in, sc_start + c);
1260 c = (c + 1) % sc_len;
1265 if (old_in == _in_map && old_out == _out_map) {
1269 PluginMapChanged (); /* EMIT SIGNAL */
1270 _mapping_changed = true;
1271 _session.set_dirty();
1277 PluginInsert::configure_io (ChanCount in, ChanCount out)
1279 Match old_match = _match;
1281 ChanCount old_internal;
1285 old_in = _configured_in;
1286 old_internal = _configured_internal;
1287 old_out = _configured_out;
1290 _configured_in = in;
1291 _configured_internal = in;
1292 _configured_out = out;
1295 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1296 * (currently _sidechain->configure_io always succeeds
1297 * since Processor::configure_io() succeeds)
1299 if (!_sidechain->configure_io (in, out)) {
1300 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1303 _configured_internal += _sidechain->input()->n_ports();
1306 /* get plugin configuration */
1307 _match = private_can_support_io_configuration (in, out);
1309 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1311 DEBUG_STR_APPEND(a, string_compose ("Match '%1': ", name()));
1312 DEBUG_STR_APPEND(a, _match);
1313 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1317 /* set the matching method and number of plugins that we will use to meet this configuration */
1318 if (set_count (_match.plugins) == false) {
1319 PluginIoReConfigure (); /* EMIT SIGNAL */
1320 _configured = false;
1324 /* configure plugins */
1325 switch (_match.method) {
1328 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1329 PluginIoReConfigure (); /* EMIT SIGNAL */
1330 _configured = false;
1338 bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1340 assert (_match.strict_io || dout.n_audio() == out.n_audio()); // sans midi bypass
1341 if (useins.n_audio() == 0) {
1344 if (_plugins.front()->configure_io (useins, dout) == false) {
1345 PluginIoReConfigure (); /* EMIT SIGNAL */
1346 _configured = false;
1352 if (_plugins.front()->configure_io (in, out) == false) {
1353 PluginIoReConfigure (); /* EMIT SIGNAL */
1354 _configured = false;
1360 bool mapping_changed = false;
1361 if (old_in == in && old_out == out
1363 && old_match.method == _match.method
1364 && _in_map.size() == _out_map.size()
1365 && _in_map.size() == get_count ()
1367 /* If the configuration has not changed, keep the mapping */
1368 if (old_internal != _configured_internal) {
1369 mapping_changed = sanitize_maps ();
1371 } else if (_match.custom_cfg && _configured) {
1372 mapping_changed = sanitize_maps ();
1375 if (is_channelstrip ()) { _maps_from_state = false; }
1377 if (_maps_from_state) {
1378 _maps_from_state = false;
1379 mapping_changed = true;
1382 /* generate a new mapping */
1383 mapping_changed = reset_map (false);
1387 if (mapping_changed) {
1388 PluginMapChanged (); /* EMIT SIGNAL */
1391 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1394 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1395 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1397 DEBUG_STR_APPEND(a, "----><----\n");
1399 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1400 DEBUG_STR_APPEND(a, " * Inputs:\n");
1401 DEBUG_STR_APPEND(a, _in_map[pc]);
1402 DEBUG_STR_APPEND(a, " * Outputs:\n");
1403 DEBUG_STR_APPEND(a, _out_map[pc]);
1405 DEBUG_STR_APPEND(a, " * Thru:\n");
1406 DEBUG_STR_APPEND(a, _thru_map);
1407 DEBUG_STR_APPEND(a, "-------->>--------\n");
1408 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1413 _no_inplace = check_inplace ();
1414 _mapping_changed = false;
1416 if (old_in != in || old_out != out || old_internal != _configured_internal
1417 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1419 PluginIoReConfigure (); /* EMIT SIGNAL */
1422 // we don't know the analysis window size, so we must work with the
1423 // current buffer size here. each request for data fills in these
1424 // buffers and the analyser makes sure it gets enough data for the
1426 session().ensure_buffer_set (_signal_analysis_inputs, in);
1427 //_signal_analysis_inputs.set_count (in);
1429 session().ensure_buffer_set (_signal_analysis_outputs, out);
1430 //_signal_analysis_outputs.set_count (out);
1432 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1435 return Processor::configure_io (in, out);
1438 /** Decide whether this PluginInsert can support a given IO configuration.
1439 * To do this, we run through a set of possible solutions in rough order of
1442 * @param in Required input channel count.
1443 * @param out Filled in with the output channel count if we return true.
1444 * @return true if the given IO configuration can be supported.
1447 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1450 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1452 return private_can_support_io_configuration (in, out).method != Impossible;
1455 /** A private version of can_support_io_configuration which returns the method
1456 * by which the configuration can be matched, rather than just whether or not
1460 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1462 if (_plugins.empty()) {
1467 if (is_channelstrip ()) {
1469 return Match (ExactMatch, 1);
1473 /* if a user specified a custom cfg, so be it. */
1476 return Match (ExactMatch, get_count(), _strict_io, true); // XXX
1479 /* try automatic configuration */
1480 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1482 PluginInfoPtr info = _plugins.front()->get_info();
1483 ChanCount inputs = info->n_inputs;
1484 ChanCount outputs = info->n_outputs;
1486 /* handle case strict-i/o */
1487 if (_strict_io && m.method != Impossible) {
1490 /* special case MIDI instruments */
1491 if (is_midi_instrument()) {
1492 // output = midi-bypass + at most master-out channels.
1493 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1494 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1495 out = ChanCount::min (out, max_out);
1496 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o instrument: %1\n", name()));
1502 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1503 /* replicate processor to match output count (generators and such)
1504 * at least enough to feed every output port. */
1505 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1506 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1507 uint32_t nout = outputs.get (*t);
1508 if (nout == 0 || inx.get(*t) == 0) { continue; }
1509 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1512 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o generator: %1\n", name()));
1513 return Match (Replicate, f, _strict_io);
1524 if (m.method != Impossible) {
1528 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1530 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
1532 if (info->reconfigurable_io()) {
1534 // TODO add sidechains here
1535 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1537 // houston, we have a problem.
1538 return Match (Impossible, 0);
1540 return Match (Delegate, 1, _strict_io);
1543 ChanCount midi_bypass;
1544 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1545 midi_bypass.set (DataType::MIDI, 1);
1548 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1550 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1551 uint32_t nin = ns_inputs.get (*t);
1552 uint32_t nout = outputs.get (*t);
1553 if (nin == 0 || inx.get(*t) == 0) { continue; }
1554 // prefer floor() so the count won't overly increase IFF (nin < nout)
1555 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1557 if (f > 0 && outputs * f >= _configured_out) {
1558 out = outputs * f + midi_bypass;
1559 return Match (Replicate, f, _strict_io);
1562 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1564 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1565 uint32_t nin = ns_inputs.get (*t);
1566 if (nin == 0 || inx.get(*t) == 0) { continue; }
1567 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1570 out = outputs * f + midi_bypass;
1571 return Match (Replicate, f, _strict_io);
1574 // add at least as many plugins needed to connect all inputs
1576 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1577 uint32_t nin = inputs.get (*t);
1578 if (nin == 0 || inx.get(*t) == 0) { continue; }
1579 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1581 out = outputs * f + midi_bypass;
1582 return Match (Replicate, f, _strict_io);
1585 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1587 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1589 if (_plugins.empty()) {
1593 PluginInfoPtr info = _plugins.front()->get_info();
1594 ChanCount in; in += inx;
1595 ChanCount midi_bypass;
1597 if (info->reconfigurable_io()) {
1598 /* Plugin has flexible I/O, so delegate to it */
1599 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1601 return Match (Impossible, 0);
1603 return Match (Delegate, 1);
1606 ChanCount inputs = info->n_inputs;
1607 ChanCount outputs = info->n_outputs;
1608 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1610 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1611 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1612 midi_bypass.set (DataType::MIDI, 1);
1614 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1615 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1616 in.set(DataType::MIDI, 0);
1619 // add internally provided sidechain ports
1620 ChanCount insc = in + sidechain_input_ports ();
1622 bool no_inputs = true;
1623 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1624 if (inputs.get (*t) != 0) {
1631 /* no inputs so we can take any input configuration since we throw it away */
1632 out = outputs + midi_bypass;
1633 return Match (NoInputs, 1);
1636 /* Plugin inputs match requested inputs + side-chain-ports exactly */
1637 if (inputs == insc) {
1638 out = outputs + midi_bypass;
1639 return Match (ExactMatch, 1);
1642 /* Plugin inputs matches without side-chain-pins */
1643 if (ns_inputs == in) {
1644 out = outputs + midi_bypass;
1645 return Match (ExactMatch, 1);
1648 /* We may be able to run more than one copy of the plugin within this insert
1649 to cope with the insert having more inputs than the plugin.
1650 We allow replication only for plugins with either zero or 1 inputs and outputs
1651 for every valid data type.
1655 bool can_replicate = true;
1656 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
1658 // ignore side-chains
1659 uint32_t nin = ns_inputs.get (*t);
1661 // No inputs of this type
1662 if (nin == 0 && in.get(*t) == 0) {
1666 if (nin != 1 || outputs.get (*t) != 1) {
1667 can_replicate = false;
1671 // Potential factor not set yet
1673 f = in.get(*t) / nin;
1676 // Factor for this type does not match another type, can not replicate
1677 if (f != (in.get(*t) / nin)) {
1678 can_replicate = false;
1683 if (can_replicate && f > 0) {
1684 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1685 out.set (*t, outputs.get(*t) * f);
1688 return Match (Replicate, f);
1691 /* If the processor has exactly one input of a given type, and
1692 the plugin has more, we can feed the single processor input
1693 to some or all of the plugin inputs. This is rather
1694 special-case-y, but the 1-to-many case is by far the
1695 simplest. How do I split thy 2 processor inputs to 3
1696 plugin inputs? Let me count the ways ...
1699 bool can_split = true;
1700 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1702 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
1703 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1705 if (!can_split_type && !nothing_to_do_for_type) {
1711 out = outputs + midi_bypass;
1712 return Match (Split, 1);
1715 /* If the plugin has more inputs than we want, we can `hide' some of them
1716 by feeding them silence.
1719 bool could_hide = false;
1720 bool cannot_hide = false;
1721 ChanCount hide_channels;
1723 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1724 if (inputs.get(*t) > in.get(*t)) {
1725 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1726 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1728 } else if (inputs.get(*t) < in.get(*t)) {
1729 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1734 if (could_hide && !cannot_hide) {
1735 out = outputs + midi_bypass;
1736 return Match (Hide, 1, false, false, hide_channels);
1739 return Match (Impossible, 0);
1744 PluginInsert::get_state ()
1746 return state (true);
1750 PluginInsert::state (bool full)
1752 XMLNode& node = Processor::state (full);
1754 node.add_property("type", _plugins[0]->state_node_name());
1755 node.add_property("unique-id", _plugins[0]->unique_id());
1756 node.add_property("count", string_compose("%1", _plugins.size()));
1758 /* remember actual i/o configuration (for later placeholder
1759 * in case the plugin goes missing) */
1760 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1761 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1763 /* save custom i/o config */
1764 node.add_property("custom", _custom_cfg ? "yes" : "no");
1765 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1767 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1768 node.add_child_nocopy (* _in_map[pc].state (tmp));
1769 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1770 node.add_child_nocopy (* _out_map[pc].state (tmp));
1772 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
1775 node.add_child_nocopy (_sidechain->state (full));
1778 _plugins[0]->set_insert_id(this->id());
1779 node.add_child_nocopy (_plugins[0]->get_state());
1781 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1782 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1784 node.add_child_nocopy (ac->get_state());
1792 PluginInsert::set_control_ids (const XMLNode& node, int version)
1794 const XMLNodeList& nlist = node.children();
1795 XMLNodeConstIterator iter;
1796 set<Evoral::Parameter>::const_iterator p;
1798 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1799 if ((*iter)->name() == Controllable::xml_node_name) {
1800 const XMLProperty* prop;
1802 uint32_t p = (uint32_t)-1;
1804 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1805 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1807 p = lv2plugin->port_index(prop->value().c_str());
1811 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1812 p = atoi (prop->value());
1815 if (p != (uint32_t)-1) {
1817 /* this may create the new controllable */
1819 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1821 #ifndef NO_PLUGIN_STATE
1825 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1827 ac->set_state (**iter, version);
1836 PluginInsert::set_state(const XMLNode& node, int version)
1838 XMLNodeList nlist = node.children();
1839 XMLNodeIterator niter;
1840 XMLPropertyList plist;
1841 const XMLProperty *prop;
1842 ARDOUR::PluginType type;
1844 if ((prop = node.property ("type")) == 0) {
1845 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1849 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1850 type = ARDOUR::LADSPA;
1851 } else if (prop->value() == X_("lv2")) {
1853 } else if (prop->value() == X_("windows-vst")) {
1854 type = ARDOUR::Windows_VST;
1855 } else if (prop->value() == X_("lxvst")) {
1856 type = ARDOUR::LXVST;
1857 } else if (prop->value() == X_("audiounit")) {
1858 type = ARDOUR::AudioUnit;
1859 } else if (prop->value() == X_("luaproc")) {
1862 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1868 prop = node.property ("unique-id");
1871 #ifdef WINDOWS_VST_SUPPORT
1872 /* older sessions contain VST plugins with only an "id" field.
1875 if (type == ARDOUR::Windows_VST) {
1876 prop = node.property ("id");
1880 #ifdef LXVST_SUPPORT
1881 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1883 if (type == ARDOUR::LXVST) {
1884 prop = node.property ("id");
1890 error << _("Plugin has no unique ID field") << endmsg;
1895 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1897 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1898 * allow to move sessions windows <> linux */
1899 #ifdef LXVST_SUPPORT
1900 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1901 type = ARDOUR::LXVST;
1902 plugin = find_plugin (_session, prop->value(), type);
1906 #ifdef WINDOWS_VST_SUPPORT
1907 if (plugin == 0 && type == ARDOUR::LXVST) {
1908 type = ARDOUR::Windows_VST;
1909 plugin = find_plugin (_session, prop->value(), type);
1914 error << string_compose(
1915 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1916 "Perhaps it was removed or moved since it was last used."),
1922 if (type == ARDOUR::Lua) {
1923 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1924 // we need to load the script to set the name and parameters.
1925 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1927 lp->set_script_from_state (*ls);
1931 // The name of the PluginInsert comes from the plugin, nothing else
1932 _name = plugin->get_info()->name;
1936 // Processor::set_state() will set this, but too late
1937 // for it to be available when setting up plugin
1938 // state. We can't call Processor::set_state() until
1939 // the plugins themselves are created and added.
1943 if (_plugins.empty()) {
1944 /* if we are adding the first plugin, we will need to set
1945 up automatable controls.
1947 add_plugin (plugin);
1948 create_automatable_parameters ();
1949 set_control_ids (node, version);
1952 if ((prop = node.property ("count")) != 0) {
1953 sscanf (prop->value().c_str(), "%u", &count);
1956 if (_plugins.size() != count) {
1957 for (uint32_t n = 1; n < count; ++n) {
1958 add_plugin (plugin_factory (plugin));
1962 Processor::set_state (node, version);
1964 PBD::ID new_id = this->id();
1965 PBD::ID old_id = this->id();
1967 if ((prop = node.property ("id")) != 0) {
1968 old_id = prop->value ();
1971 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1973 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1974 and set all plugins to the same state.
1977 if ((*niter)->name() == plugin->state_node_name()) {
1979 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1980 /* Plugin state can include external files which are named after the ID.
1982 * If regenerate_xml_or_string_ids() is set, the ID will already have
1983 * been changed, so we need to use the old ID from the XML to load the
1984 * state and then update the ID.
1986 * When copying a plugin-state, route_ui takes care of of updating the ID,
1987 * but we need to call set_insert_id() to clear the cached plugin-state
1988 * and force a change.
1990 if (!regenerate_xml_or_string_ids ()) {
1991 (*i)->set_insert_id (new_id);
1993 (*i)->set_insert_id (old_id);
1996 (*i)->set_state (**niter, version);
1998 if (regenerate_xml_or_string_ids ()) {
1999 (*i)->set_insert_id (new_id);
2007 if (version < 3000) {
2009 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2010 this is all handled by Automatable
2013 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2014 if ((*niter)->name() == "Redirect") {
2015 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2016 Processor::set_state (**niter, version);
2021 set_parameter_state_2X (node, version);
2024 if ((prop = node.property (X_("custom"))) != 0) {
2025 _custom_cfg = string_is_affirmative (prop->value());
2028 // TODO load/add sidechain
2030 uint32_t in_maps = 0;
2031 uint32_t out_maps = 0;
2032 XMLNodeList kids = node.children ();
2033 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2034 if ((*i)->name() == X_("ConfiguredOutput")) {
2035 _custom_out = ChanCount(**i);
2037 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2038 long pc = atol (&((*i)->name().c_str()[9]));
2039 if (pc >=0 && pc <= get_count()) {
2040 _in_map[pc] = ChanMapping (**i);
2044 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2045 long pc = atol (&((*i)->name().c_str()[10]));
2046 if (pc >=0 && pc <= get_count()) {
2047 _out_map[pc] = ChanMapping (**i);
2051 if ((*i)->name () == "ThruMap") {
2052 _thru_map = ChanMapping (**i);
2054 if ((*i)->name () == Processor::state_node_name) {
2058 _sidechain->set_state (**i, version);
2062 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2063 _maps_from_state = true;
2066 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2070 (*i)->deactivate ();
2078 PluginInsert::update_id (PBD::ID id)
2081 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2082 (*i)->set_insert_id (id);
2087 PluginInsert::set_state_dir (const std::string& d)
2089 // state() only saves the state of the first plugin
2090 _plugins[0]->set_state_dir (d);
2094 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2096 XMLNodeList nlist = node.children();
2097 XMLNodeIterator niter;
2099 /* look for port automation node */
2101 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2103 if ((*niter)->name() != port_automation_node_name) {
2109 XMLNodeConstIterator iter;
2114 cnodes = (*niter)->children ("port");
2116 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2120 if ((cprop = child->property("number")) != 0) {
2121 port = cprop->value().c_str();
2123 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2127 sscanf (port, "%" PRIu32, &port_id);
2129 if (port_id >= _plugins[0]->parameter_count()) {
2130 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2134 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2135 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2137 if (c && c->alist()) {
2138 if (!child->children().empty()) {
2139 c->alist()->set_state (*child->children().front(), version);
2141 /* In some cases 2.X saves lists with min_yval and max_yval
2142 being FLT_MIN and FLT_MAX respectively. This causes problems
2143 in A3 because these min/max values are used to compute
2144 where GUI control points should be drawn. If we see such
2145 values, `correct' them to the min/max of the appropriate
2149 float min_y = c->alist()->get_min_y ();
2150 float max_y = c->alist()->get_max_y ();
2152 ParameterDescriptor desc;
2153 _plugins.front()->get_parameter_descriptor (port_id, desc);
2155 if (min_y == FLT_MIN) {
2159 if (max_y == FLT_MAX) {
2163 c->alist()->set_yrange (min_y, max_y);
2166 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2178 PluginInsert::describe_parameter (Evoral::Parameter param)
2180 if (param.type() == PluginAutomation) {
2181 return _plugins[0]->describe_parameter (param);
2182 } else if (param.type() == PluginPropertyAutomation) {
2183 boost::shared_ptr<AutomationControl> c(automation_control(param));
2184 if (c && !c->desc().label.empty()) {
2185 return c->desc().label;
2188 return Automatable::describe_parameter(param);
2192 PluginInsert::signal_latency() const
2194 if (_user_latency) {
2195 return _user_latency;
2198 return _plugins[0]->signal_latency ();
2202 PluginInsert::type ()
2204 return plugin()->get_info()->type;
2207 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2208 const Evoral::Parameter& param,
2209 const ParameterDescriptor& desc,
2210 boost::shared_ptr<AutomationList> list)
2211 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2215 alist()->reset_default (desc.normal);
2217 list->set_interpolation(Evoral::ControlList::Discrete);
2222 set_flags(Controllable::Toggle);
2226 /** @param val `user' value */
2228 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2231 _set_value (user_val, group_override);
2235 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2237 /* used only by automation playback */
2238 _set_value (user_val, Controllable::NoGroup);
2242 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2244 /* FIXME: probably should be taking out some lock here.. */
2246 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2247 (*i)->set_parameter (_list->parameter().id(), user_val);
2250 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2252 iasp->set_parameter (_list->parameter().id(), user_val);
2255 AutomationControl::set_value (user_val, group_override);
2259 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2261 AutomationControl::set_value (user_val, Controllable::NoGroup);
2265 PluginInsert::PluginControl::get_state ()
2269 XMLNode& node (AutomationControl::get_state());
2270 ss << parameter().id();
2271 node.add_property (X_("parameter"), ss.str());
2273 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2275 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2282 /** @return `user' val */
2284 PluginInsert::PluginControl::get_value () const
2286 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2292 return plugin->get_parameter (_list->parameter().id());
2295 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2296 const Evoral::Parameter& param,
2297 const ParameterDescriptor& desc,
2298 boost::shared_ptr<AutomationList> list)
2299 : AutomationControl (p->session(), param, desc, list)
2303 alist()->set_yrange (desc.lower, desc.upper);
2304 alist()->reset_default (desc.normal);
2308 set_flags(Controllable::Toggle);
2313 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2316 set_value_unchecked (user_val);
2321 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2323 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2324 This is lossy, but better than nothing until Ardour's automation system
2325 can handle various datatypes all the way down. */
2326 const Variant value(_desc.datatype, user_val);
2327 if (value.type() == Variant::NOTHING) {
2328 error << "set_value(double) called for non-numeric property" << endmsg;
2332 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2333 (*i)->set_property(_list->parameter().id(), value);
2337 AutomationControl::set_value (user_val, Controllable::NoGroup);
2341 PluginInsert::PluginPropertyControl::get_state ()
2345 XMLNode& node (AutomationControl::get_state());
2346 ss << parameter().id();
2347 node.add_property (X_("property"), ss.str());
2348 node.remove_property (X_("value"));
2354 PluginInsert::PluginPropertyControl::get_value () const
2356 return _value.to_double();
2359 boost::shared_ptr<Plugin>
2360 PluginInsert::get_impulse_analysis_plugin()
2362 boost::shared_ptr<Plugin> ret;
2363 if (_impulseAnalysisPlugin.expired()) {
2364 ret = plugin_factory(_plugins[0]);
2365 ret->configure_io (internal_input_streams (), internal_output_streams ());
2366 _impulseAnalysisPlugin = ret;
2368 ret = _impulseAnalysisPlugin.lock();
2375 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2377 // called from outside the audio thread, so this should be safe
2378 // only do audio as analysis is (currently) only for audio plugins
2379 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, internal_input_streams().n_audio(), nframes);
2380 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2382 _signal_analysis_collected_nframes = 0;
2383 _signal_analysis_collect_nframes_max = nframes;
2386 /** Add a plugin to our list */
2388 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2390 plugin->set_insert_id (this->id());
2392 if (_plugins.empty()) {
2393 /* first (and probably only) plugin instance - connect to relevant signals */
2395 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2396 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2397 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2398 // cache sidechain ports
2399 _cached_sidechain_pins.reset ();
2400 const ChanCount& nis (plugin->get_info()->n_inputs);
2401 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2402 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2403 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2404 if (iod.is_sidechain) {
2405 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2410 _plugins.push_back (plugin);
2414 PluginInsert::realtime_handle_transport_stopped ()
2416 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2417 (*i)->realtime_handle_transport_stopped ();
2422 PluginInsert::realtime_locate ()
2424 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2425 (*i)->realtime_locate ();
2430 PluginInsert::monitoring_changed ()
2432 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2433 (*i)->monitoring_changed ();
2438 PluginInsert::start_touch (uint32_t param_id)
2440 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2442 ac->start_touch (session().audible_frame());
2447 PluginInsert::end_touch (uint32_t param_id)
2449 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2451 ac->stop_touch (true, session().audible_frame());
2455 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2458 case PluginInsert::Impossible: o << "Impossible"; break;
2459 case PluginInsert::Delegate: o << "Delegate"; break;
2460 case PluginInsert::NoInputs: o << "NoInputs"; break;
2461 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2462 case PluginInsert::Replicate: o << "Replicate"; break;
2463 case PluginInsert::Split: o << "Split"; break;
2464 case PluginInsert::Hide: o << "Hide"; break;
2466 o << " cnt: " << m.plugins
2467 << (m.strict_io ? " strict-io" : "")
2468 << (m.custom_cfg ? " custom-cfg" : "");
2469 if (m.method == PluginInsert::Hide) {
2470 o << " hide: " << m.hide;