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;
980 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
981 if (num < _out_map.size()) {
982 bool changed = _out_map[num] != m;
984 changed |= sanitize_maps ();
986 PluginMapChanged (); /* EMIT SIGNAL */
987 _mapping_changed = true;
993 PluginInsert::set_thru_map (ChanMapping m) {
994 bool changed = _thru_map != m;
996 changed |= sanitize_maps ();
998 PluginMapChanged (); /* EMIT SIGNAL */
999 _mapping_changed = true;
1004 PluginInsert::input_map () const
1008 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1009 ChanMapping m (i->second);
1010 const ChanMapping::Mappings& mp ((*i).second.mappings());
1011 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1012 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1013 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1021 PluginInsert::output_map () const
1025 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1026 ChanMapping m (i->second);
1027 const ChanMapping::Mappings& mp ((*i).second.mappings());
1028 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1029 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1030 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1034 if (has_midi_bypass ()) {
1035 rv.set (DataType::MIDI, 0, 0);
1042 PluginInsert::has_midi_bypass () const
1044 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1045 && natural_output_streams ().n_midi () == 0) {
1052 PluginInsert::has_midi_thru () const
1054 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1055 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1063 PluginInsert::is_channelstrip () const {
1064 return _plugins.front()->is_channelstrip();
1069 PluginInsert::check_inplace ()
1071 bool inplace_ok = !_plugins.front()->inplace_broken ();
1073 if (_thru_map.count () > 0) {
1074 // TODO once midi-bypass is part of the mapping, ignore it
1078 if (_match.method == Split && inplace_ok) {
1079 assert (get_count() == 1);
1080 assert (_in_map.size () == 1);
1081 if (!_out_map[0].is_monotonic ()) {
1084 if (_configured_internal != _configured_in) {
1085 /* no sidechain -- TODO we could allow this with
1086 * some more logic in PluginInsert::connect_and_run().
1088 * PluginInsert::reset_map() already maps it.
1093 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1094 if (_configured_internal.get (*t) == 0) {
1098 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1099 if (!valid || first_idx != 0) {
1100 // so far only allow to copy the *first* stream's buffer to others
1103 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1104 uint32_t idx = _in_map[0].get (*t, i, &valid);
1105 if (valid && idx != first_idx) {
1114 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1119 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1120 if (!_in_map[pc].is_monotonic ()) {
1123 if (!_out_map[pc].is_monotonic ()) {
1127 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1128 return !inplace_ok; // no-inplace
1132 PluginInsert::sanitize_maps ()
1134 bool changed = false;
1135 /* strip dead wood */
1136 PinMappings new_ins;
1137 PinMappings new_outs;
1138 ChanMapping new_thru (_thru_map);
1140 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1142 ChanMapping new_out;
1143 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1144 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1146 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1147 if (valid && idx < _configured_internal.get (*t)) {
1148 new_in.set (*t, i, idx);
1151 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1153 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1154 if (valid && idx < _configured_out.get (*t)) {
1155 new_out.set (*t, o, idx);
1159 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1162 new_ins[pc] = new_in;
1163 new_outs[pc] = new_out;
1166 /* prevent dup output assignments */
1167 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1168 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1169 bool mapped = false;
1170 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1172 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1173 if (valid && mapped) {
1174 new_outs[pc].unset (*t, idx);
1182 /* prevent out + thru, existing plugin outputs override thru */
1183 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1184 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1185 bool mapped = false;
1187 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1188 new_outs[pc].get_src (*t, o, &mapped);
1189 if (mapped) { break; }
1191 if (!mapped) { continue; }
1192 uint32_t idx = new_thru.get (*t, o, &valid);
1194 new_thru.unset (*t, idx);
1199 if (has_midi_bypass ()) {
1200 // TODO: include midi-bypass in the thru set,
1201 // remove dedicated handling.
1202 new_thru.unset (DataType::MIDI, 0);
1205 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1209 _out_map = new_outs;
1210 _thru_map = new_thru;
1216 PluginInsert::reset_map (bool emit)
1219 const PinMappings old_in (_in_map);
1220 const PinMappings old_out (_out_map);
1224 _thru_map = ChanMapping ();
1225 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1226 ChanCount ns_inputs = natural_input_streams() - sidechain_input_pins ();
1227 if (_match.method == Split) {
1228 _in_map[pc] = ChanMapping ();
1229 /* connect no sidechain sinks in round-robin fashion */
1230 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1231 const uint32_t cend = _configured_in.get (*t);
1232 if (cend == 0) { continue; }
1234 for (uint32_t in = 0; in < ns_inputs.get (*t); ++in) {
1235 _in_map[pc].set (*t, in, c);
1240 _in_map[pc] = ChanMapping (ChanCount::min (ns_inputs, _configured_in));
1242 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1244 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1245 const uint32_t nis = natural_input_streams ().get(*t);
1246 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1247 _in_map[pc].offset_to(*t, stride * pc);
1248 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1250 // connect side-chains
1251 const uint32_t sc_start = _configured_in.get (*t);
1252 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1253 if (sc_len == 0) { continue; }
1255 for (uint32_t in = ns_inputs.get (*t); in < nis; ++in) {
1256 _in_map[pc].set (*t, in, sc_start + c);
1257 c = (c + 1) % sc_len;
1262 if (old_in == _in_map && old_out == _out_map) {
1266 PluginMapChanged (); /* EMIT SIGNAL */
1267 _mapping_changed = true;
1273 PluginInsert::configure_io (ChanCount in, ChanCount out)
1275 Match old_match = _match;
1277 ChanCount old_internal;
1281 old_in = _configured_in;
1282 old_internal = _configured_internal;
1283 old_out = _configured_out;
1286 _configured_in = in;
1287 _configured_internal = in;
1288 _configured_out = out;
1291 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1292 * (currently _sidechain->configure_io always succeeds
1293 * since Processor::configure_io() succeeds)
1295 if (!_sidechain->configure_io (in, out)) {
1296 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1299 _configured_internal += _sidechain->input()->n_ports();
1302 /* get plugin configuration */
1303 _match = private_can_support_io_configuration (in, out);
1305 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1307 DEBUG_STR_APPEND(a, string_compose ("Match '%1': ", name()));
1308 DEBUG_STR_APPEND(a, _match);
1309 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1313 /* set the matching method and number of plugins that we will use to meet this configuration */
1314 if (set_count (_match.plugins) == false) {
1315 PluginIoReConfigure (); /* EMIT SIGNAL */
1316 _configured = false;
1320 /* configure plugins */
1321 switch (_match.method) {
1324 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1325 PluginIoReConfigure (); /* EMIT SIGNAL */
1326 _configured = false;
1334 bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1336 assert (_match.strict_io || dout.n_audio() == out.n_audio()); // sans midi bypass
1337 if (useins.n_audio() == 0) {
1340 if (_plugins.front()->configure_io (useins, dout) == false) {
1341 PluginIoReConfigure (); /* EMIT SIGNAL */
1342 _configured = false;
1348 if (_plugins.front()->configure_io (in, out) == false) {
1349 PluginIoReConfigure (); /* EMIT SIGNAL */
1350 _configured = false;
1356 bool mapping_changed = false;
1357 if (old_in == in && old_out == out
1359 && old_match.method == _match.method
1360 && _in_map.size() == _out_map.size()
1361 && _in_map.size() == get_count ()
1363 /* If the configuration has not changed, keep the mapping */
1364 if (old_internal != _configured_internal) {
1365 mapping_changed = sanitize_maps ();
1367 } else if (_match.custom_cfg && _configured) {
1368 mapping_changed = sanitize_maps ();
1371 if (is_channelstrip ()) { _maps_from_state = false; }
1373 if (_maps_from_state) {
1374 _maps_from_state = false;
1375 mapping_changed = true;
1378 /* generate a new mapping */
1379 mapping_changed = reset_map (false);
1383 if (mapping_changed) {
1384 PluginMapChanged (); /* EMIT SIGNAL */
1387 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1390 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1391 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1393 DEBUG_STR_APPEND(a, "----><----\n");
1395 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1396 DEBUG_STR_APPEND(a, " * Inputs:\n");
1397 DEBUG_STR_APPEND(a, _in_map[pc]);
1398 DEBUG_STR_APPEND(a, " * Outputs:\n");
1399 DEBUG_STR_APPEND(a, _out_map[pc]);
1401 DEBUG_STR_APPEND(a, " * Thru:\n");
1402 DEBUG_STR_APPEND(a, _thru_map);
1403 DEBUG_STR_APPEND(a, "-------->>--------\n");
1404 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1409 _no_inplace = check_inplace ();
1410 _mapping_changed = false;
1412 if (old_in != in || old_out != out || old_internal != _configured_internal
1413 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1415 PluginIoReConfigure (); /* EMIT SIGNAL */
1418 // we don't know the analysis window size, so we must work with the
1419 // current buffer size here. each request for data fills in these
1420 // buffers and the analyser makes sure it gets enough data for the
1422 session().ensure_buffer_set (_signal_analysis_inputs, in);
1423 //_signal_analysis_inputs.set_count (in);
1425 session().ensure_buffer_set (_signal_analysis_outputs, out);
1426 //_signal_analysis_outputs.set_count (out);
1428 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1431 return Processor::configure_io (in, out);
1434 /** Decide whether this PluginInsert can support a given IO configuration.
1435 * To do this, we run through a set of possible solutions in rough order of
1438 * @param in Required input channel count.
1439 * @param out Filled in with the output channel count if we return true.
1440 * @return true if the given IO configuration can be supported.
1443 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1446 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1448 return private_can_support_io_configuration (in, out).method != Impossible;
1451 /** A private version of can_support_io_configuration which returns the method
1452 * by which the configuration can be matched, rather than just whether or not
1456 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1458 if (_plugins.empty()) {
1463 if (is_channelstrip ()) {
1465 return Match (ExactMatch, 1);
1469 /* if a user specified a custom cfg, so be it. */
1472 return Match (ExactMatch, get_count(), _strict_io, true); // XXX
1475 /* try automatic configuration */
1476 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1478 PluginInfoPtr info = _plugins.front()->get_info();
1479 ChanCount inputs = info->n_inputs;
1480 ChanCount outputs = info->n_outputs;
1482 /* handle case strict-i/o */
1483 if (_strict_io && m.method != Impossible) {
1486 /* special case MIDI instruments */
1487 if (is_midi_instrument()) {
1488 // output = midi-bypass + at most master-out channels.
1489 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1490 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1491 out = ChanCount::min (out, max_out);
1492 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o instrument: %1\n", name()));
1498 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1499 /* replicate processor to match output count (generators and such)
1500 * at least enough to feed every output port. */
1501 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1502 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1503 uint32_t nout = outputs.get (*t);
1504 if (nout == 0 || inx.get(*t) == 0) { continue; }
1505 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1508 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o generator: %1\n", name()));
1509 return Match (Replicate, f, _strict_io);
1520 if (m.method != Impossible) {
1524 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1526 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
1528 if (info->reconfigurable_io()) {
1530 // TODO add sidechains here
1531 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1533 // houston, we have a problem.
1534 return Match (Impossible, 0);
1536 return Match (Delegate, 1, _strict_io);
1539 ChanCount midi_bypass;
1540 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1541 midi_bypass.set (DataType::MIDI, 1);
1544 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1546 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1547 uint32_t nin = ns_inputs.get (*t);
1548 uint32_t nout = outputs.get (*t);
1549 if (nin == 0 || inx.get(*t) == 0) { continue; }
1550 // prefer floor() so the count won't overly increase IFF (nin < nout)
1551 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1553 if (f > 0 && outputs * f >= _configured_out) {
1554 out = outputs * f + midi_bypass;
1555 return Match (Replicate, f, _strict_io);
1558 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1560 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1561 uint32_t nin = ns_inputs.get (*t);
1562 if (nin == 0 || inx.get(*t) == 0) { continue; }
1563 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1566 out = outputs * f + midi_bypass;
1567 return Match (Replicate, f, _strict_io);
1570 // add at least as many plugins needed to connect all inputs
1572 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1573 uint32_t nin = inputs.get (*t);
1574 if (nin == 0 || inx.get(*t) == 0) { continue; }
1575 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1577 out = outputs * f + midi_bypass;
1578 return Match (Replicate, f, _strict_io);
1581 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1583 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1585 if (_plugins.empty()) {
1589 PluginInfoPtr info = _plugins.front()->get_info();
1590 ChanCount in; in += inx;
1591 ChanCount midi_bypass;
1593 if (info->reconfigurable_io()) {
1594 /* Plugin has flexible I/O, so delegate to it */
1595 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1597 return Match (Impossible, 0);
1599 return Match (Delegate, 1);
1602 ChanCount inputs = info->n_inputs;
1603 ChanCount outputs = info->n_outputs;
1604 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1606 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1607 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1608 midi_bypass.set (DataType::MIDI, 1);
1610 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1611 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1612 in.set(DataType::MIDI, 0);
1615 // add internally provided sidechain ports
1616 ChanCount insc = in + sidechain_input_ports ();
1618 bool no_inputs = true;
1619 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1620 if (inputs.get (*t) != 0) {
1627 /* no inputs so we can take any input configuration since we throw it away */
1628 out = outputs + midi_bypass;
1629 return Match (NoInputs, 1);
1632 /* Plugin inputs match requested inputs + side-chain-ports exactly */
1633 if (inputs == insc) {
1634 out = outputs + midi_bypass;
1635 return Match (ExactMatch, 1);
1638 /* Plugin inputs matches without side-chain-pins */
1639 if (ns_inputs == in) {
1640 out = outputs + midi_bypass;
1641 return Match (ExactMatch, 1);
1644 /* We may be able to run more than one copy of the plugin within this insert
1645 to cope with the insert having more inputs than the plugin.
1646 We allow replication only for plugins with either zero or 1 inputs and outputs
1647 for every valid data type.
1651 bool can_replicate = true;
1652 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
1654 // ignore side-chains
1655 uint32_t nin = ns_inputs.get (*t);
1657 // No inputs of this type
1658 if (nin == 0 && in.get(*t) == 0) {
1662 if (nin != 1 || outputs.get (*t) != 1) {
1663 can_replicate = false;
1667 // Potential factor not set yet
1669 f = in.get(*t) / nin;
1672 // Factor for this type does not match another type, can not replicate
1673 if (f != (in.get(*t) / nin)) {
1674 can_replicate = false;
1679 if (can_replicate && f > 0) {
1680 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1681 out.set (*t, outputs.get(*t) * f);
1684 return Match (Replicate, f);
1687 /* If the processor has exactly one input of a given type, and
1688 the plugin has more, we can feed the single processor input
1689 to some or all of the plugin inputs. This is rather
1690 special-case-y, but the 1-to-many case is by far the
1691 simplest. How do I split thy 2 processor inputs to 3
1692 plugin inputs? Let me count the ways ...
1695 bool can_split = true;
1696 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1698 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
1699 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1701 if (!can_split_type && !nothing_to_do_for_type) {
1707 out = outputs + midi_bypass;
1708 return Match (Split, 1);
1711 /* If the plugin has more inputs than we want, we can `hide' some of them
1712 by feeding them silence.
1715 bool could_hide = false;
1716 bool cannot_hide = false;
1717 ChanCount hide_channels;
1719 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1720 if (inputs.get(*t) > in.get(*t)) {
1721 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1722 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1724 } else if (inputs.get(*t) < in.get(*t)) {
1725 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1730 if (could_hide && !cannot_hide) {
1731 out = outputs + midi_bypass;
1732 return Match (Hide, 1, false, false, hide_channels);
1735 return Match (Impossible, 0);
1740 PluginInsert::get_state ()
1742 return state (true);
1746 PluginInsert::state (bool full)
1748 XMLNode& node = Processor::state (full);
1750 node.add_property("type", _plugins[0]->state_node_name());
1751 node.add_property("unique-id", _plugins[0]->unique_id());
1752 node.add_property("count", string_compose("%1", _plugins.size()));
1754 /* remember actual i/o configuration (for later placeholder
1755 * in case the plugin goes missing) */
1756 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1757 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1759 /* save custom i/o config */
1760 node.add_property("custom", _custom_cfg ? "yes" : "no");
1761 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1763 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1764 node.add_child_nocopy (* _in_map[pc].state (tmp));
1765 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1766 node.add_child_nocopy (* _out_map[pc].state (tmp));
1768 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
1771 node.add_child_nocopy (_sidechain->state (full));
1774 _plugins[0]->set_insert_id(this->id());
1775 node.add_child_nocopy (_plugins[0]->get_state());
1777 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1778 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1780 node.add_child_nocopy (ac->get_state());
1788 PluginInsert::set_control_ids (const XMLNode& node, int version)
1790 const XMLNodeList& nlist = node.children();
1791 XMLNodeConstIterator iter;
1792 set<Evoral::Parameter>::const_iterator p;
1794 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1795 if ((*iter)->name() == Controllable::xml_node_name) {
1796 const XMLProperty* prop;
1798 uint32_t p = (uint32_t)-1;
1800 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1801 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1803 p = lv2plugin->port_index(prop->value().c_str());
1807 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1808 p = atoi (prop->value());
1811 if (p != (uint32_t)-1) {
1813 /* this may create the new controllable */
1815 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1817 #ifndef NO_PLUGIN_STATE
1821 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1823 ac->set_state (**iter, version);
1832 PluginInsert::set_state(const XMLNode& node, int version)
1834 XMLNodeList nlist = node.children();
1835 XMLNodeIterator niter;
1836 XMLPropertyList plist;
1837 const XMLProperty *prop;
1838 ARDOUR::PluginType type;
1840 if ((prop = node.property ("type")) == 0) {
1841 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1845 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1846 type = ARDOUR::LADSPA;
1847 } else if (prop->value() == X_("lv2")) {
1849 } else if (prop->value() == X_("windows-vst")) {
1850 type = ARDOUR::Windows_VST;
1851 } else if (prop->value() == X_("lxvst")) {
1852 type = ARDOUR::LXVST;
1853 } else if (prop->value() == X_("audiounit")) {
1854 type = ARDOUR::AudioUnit;
1855 } else if (prop->value() == X_("luaproc")) {
1858 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1864 prop = node.property ("unique-id");
1867 #ifdef WINDOWS_VST_SUPPORT
1868 /* older sessions contain VST plugins with only an "id" field.
1871 if (type == ARDOUR::Windows_VST) {
1872 prop = node.property ("id");
1876 #ifdef LXVST_SUPPORT
1877 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1879 if (type == ARDOUR::LXVST) {
1880 prop = node.property ("id");
1886 error << _("Plugin has no unique ID field") << endmsg;
1891 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1893 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1894 * allow to move sessions windows <> linux */
1895 #ifdef LXVST_SUPPORT
1896 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1897 type = ARDOUR::LXVST;
1898 plugin = find_plugin (_session, prop->value(), type);
1902 #ifdef WINDOWS_VST_SUPPORT
1903 if (plugin == 0 && type == ARDOUR::LXVST) {
1904 type = ARDOUR::Windows_VST;
1905 plugin = find_plugin (_session, prop->value(), type);
1910 error << string_compose(
1911 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1912 "Perhaps it was removed or moved since it was last used."),
1918 if (type == ARDOUR::Lua) {
1919 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1920 // we need to load the script to set the name and parameters.
1921 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1923 lp->set_script_from_state (*ls);
1927 // The name of the PluginInsert comes from the plugin, nothing else
1928 _name = plugin->get_info()->name;
1932 // Processor::set_state() will set this, but too late
1933 // for it to be available when setting up plugin
1934 // state. We can't call Processor::set_state() until
1935 // the plugins themselves are created and added.
1939 if (_plugins.empty()) {
1940 /* if we are adding the first plugin, we will need to set
1941 up automatable controls.
1943 add_plugin (plugin);
1944 create_automatable_parameters ();
1945 set_control_ids (node, version);
1948 if ((prop = node.property ("count")) != 0) {
1949 sscanf (prop->value().c_str(), "%u", &count);
1952 if (_plugins.size() != count) {
1953 for (uint32_t n = 1; n < count; ++n) {
1954 add_plugin (plugin_factory (plugin));
1958 Processor::set_state (node, version);
1960 PBD::ID new_id = this->id();
1961 PBD::ID old_id = this->id();
1963 if ((prop = node.property ("id")) != 0) {
1964 old_id = prop->value ();
1967 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1969 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1970 and set all plugins to the same state.
1973 if ((*niter)->name() == plugin->state_node_name()) {
1975 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1976 /* Plugin state can include external files which are named after the ID.
1978 * If regenerate_xml_or_string_ids() is set, the ID will already have
1979 * been changed, so we need to use the old ID from the XML to load the
1980 * state and then update the ID.
1982 * When copying a plugin-state, route_ui takes care of of updating the ID,
1983 * but we need to call set_insert_id() to clear the cached plugin-state
1984 * and force a change.
1986 if (!regenerate_xml_or_string_ids ()) {
1987 (*i)->set_insert_id (new_id);
1989 (*i)->set_insert_id (old_id);
1992 (*i)->set_state (**niter, version);
1994 if (regenerate_xml_or_string_ids ()) {
1995 (*i)->set_insert_id (new_id);
2003 if (version < 3000) {
2005 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2006 this is all handled by Automatable
2009 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2010 if ((*niter)->name() == "Redirect") {
2011 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2012 Processor::set_state (**niter, version);
2017 set_parameter_state_2X (node, version);
2020 if ((prop = node.property (X_("custom"))) != 0) {
2021 _custom_cfg = string_is_affirmative (prop->value());
2024 // TODO load/add sidechain
2026 uint32_t in_maps = 0;
2027 uint32_t out_maps = 0;
2028 XMLNodeList kids = node.children ();
2029 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2030 if ((*i)->name() == X_("ConfiguredOutput")) {
2031 _custom_out = ChanCount(**i);
2033 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2034 long pc = atol (&((*i)->name().c_str()[9]));
2035 if (pc >=0 && pc <= get_count()) {
2036 _in_map[pc] = ChanMapping (**i);
2040 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2041 long pc = atol (&((*i)->name().c_str()[10]));
2042 if (pc >=0 && pc <= get_count()) {
2043 _out_map[pc] = ChanMapping (**i);
2047 if ((*i)->name () == "ThruMap") {
2048 _thru_map = ChanMapping (**i);
2050 if ((*i)->name () == Processor::state_node_name) {
2054 _sidechain->set_state (**i, version);
2058 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2059 _maps_from_state = true;
2062 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2066 (*i)->deactivate ();
2074 PluginInsert::update_id (PBD::ID id)
2077 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2078 (*i)->set_insert_id (id);
2083 PluginInsert::set_state_dir (const std::string& d)
2085 // state() only saves the state of the first plugin
2086 _plugins[0]->set_state_dir (d);
2090 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2092 XMLNodeList nlist = node.children();
2093 XMLNodeIterator niter;
2095 /* look for port automation node */
2097 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2099 if ((*niter)->name() != port_automation_node_name) {
2105 XMLNodeConstIterator iter;
2110 cnodes = (*niter)->children ("port");
2112 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2116 if ((cprop = child->property("number")) != 0) {
2117 port = cprop->value().c_str();
2119 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2123 sscanf (port, "%" PRIu32, &port_id);
2125 if (port_id >= _plugins[0]->parameter_count()) {
2126 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2130 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2131 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2133 if (c && c->alist()) {
2134 if (!child->children().empty()) {
2135 c->alist()->set_state (*child->children().front(), version);
2137 /* In some cases 2.X saves lists with min_yval and max_yval
2138 being FLT_MIN and FLT_MAX respectively. This causes problems
2139 in A3 because these min/max values are used to compute
2140 where GUI control points should be drawn. If we see such
2141 values, `correct' them to the min/max of the appropriate
2145 float min_y = c->alist()->get_min_y ();
2146 float max_y = c->alist()->get_max_y ();
2148 ParameterDescriptor desc;
2149 _plugins.front()->get_parameter_descriptor (port_id, desc);
2151 if (min_y == FLT_MIN) {
2155 if (max_y == FLT_MAX) {
2159 c->alist()->set_yrange (min_y, max_y);
2162 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2174 PluginInsert::describe_parameter (Evoral::Parameter param)
2176 if (param.type() == PluginAutomation) {
2177 return _plugins[0]->describe_parameter (param);
2178 } else if (param.type() == PluginPropertyAutomation) {
2179 boost::shared_ptr<AutomationControl> c(automation_control(param));
2180 if (c && !c->desc().label.empty()) {
2181 return c->desc().label;
2184 return Automatable::describe_parameter(param);
2188 PluginInsert::signal_latency() const
2190 if (_user_latency) {
2191 return _user_latency;
2194 return _plugins[0]->signal_latency ();
2198 PluginInsert::type ()
2200 return plugin()->get_info()->type;
2203 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2204 const Evoral::Parameter& param,
2205 const ParameterDescriptor& desc,
2206 boost::shared_ptr<AutomationList> list)
2207 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2211 alist()->reset_default (desc.normal);
2213 list->set_interpolation(Evoral::ControlList::Discrete);
2218 set_flags(Controllable::Toggle);
2222 /** @param val `user' value */
2224 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2227 _set_value (user_val, group_override);
2231 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2233 /* used only by automation playback */
2234 _set_value (user_val, Controllable::NoGroup);
2238 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2240 /* FIXME: probably should be taking out some lock here.. */
2242 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2243 (*i)->set_parameter (_list->parameter().id(), user_val);
2246 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2248 iasp->set_parameter (_list->parameter().id(), user_val);
2251 AutomationControl::set_value (user_val, group_override);
2255 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2257 AutomationControl::set_value (user_val, Controllable::NoGroup);
2261 PluginInsert::PluginControl::get_state ()
2265 XMLNode& node (AutomationControl::get_state());
2266 ss << parameter().id();
2267 node.add_property (X_("parameter"), ss.str());
2269 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2271 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2278 /** @return `user' val */
2280 PluginInsert::PluginControl::get_value () const
2282 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2288 return plugin->get_parameter (_list->parameter().id());
2291 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2292 const Evoral::Parameter& param,
2293 const ParameterDescriptor& desc,
2294 boost::shared_ptr<AutomationList> list)
2295 : AutomationControl (p->session(), param, desc, list)
2299 alist()->set_yrange (desc.lower, desc.upper);
2300 alist()->reset_default (desc.normal);
2304 set_flags(Controllable::Toggle);
2309 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2312 set_value_unchecked (user_val);
2317 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2319 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2320 This is lossy, but better than nothing until Ardour's automation system
2321 can handle various datatypes all the way down. */
2322 const Variant value(_desc.datatype, user_val);
2323 if (value.type() == Variant::NOTHING) {
2324 error << "set_value(double) called for non-numeric property" << endmsg;
2328 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2329 (*i)->set_property(_list->parameter().id(), value);
2333 AutomationControl::set_value (user_val, Controllable::NoGroup);
2337 PluginInsert::PluginPropertyControl::get_state ()
2341 XMLNode& node (AutomationControl::get_state());
2342 ss << parameter().id();
2343 node.add_property (X_("property"), ss.str());
2344 node.remove_property (X_("value"));
2350 PluginInsert::PluginPropertyControl::get_value () const
2352 return _value.to_double();
2355 boost::shared_ptr<Plugin>
2356 PluginInsert::get_impulse_analysis_plugin()
2358 boost::shared_ptr<Plugin> ret;
2359 if (_impulseAnalysisPlugin.expired()) {
2360 ret = plugin_factory(_plugins[0]);
2361 ret->configure_io (internal_input_streams (), internal_output_streams ());
2362 _impulseAnalysisPlugin = ret;
2364 ret = _impulseAnalysisPlugin.lock();
2371 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2373 // called from outside the audio thread, so this should be safe
2374 // only do audio as analysis is (currently) only for audio plugins
2375 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, internal_input_streams().n_audio(), nframes);
2376 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2378 _signal_analysis_collected_nframes = 0;
2379 _signal_analysis_collect_nframes_max = nframes;
2382 /** Add a plugin to our list */
2384 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2386 plugin->set_insert_id (this->id());
2388 if (_plugins.empty()) {
2389 /* first (and probably only) plugin instance - connect to relevant signals */
2391 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2392 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2393 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2394 // cache sidechain ports
2395 _cached_sidechain_pins.reset ();
2396 const ChanCount& nis (plugin->get_info()->n_inputs);
2397 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2398 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2399 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2400 if (iod.is_sidechain) {
2401 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2406 _plugins.push_back (plugin);
2410 PluginInsert::realtime_handle_transport_stopped ()
2412 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2413 (*i)->realtime_handle_transport_stopped ();
2418 PluginInsert::realtime_locate ()
2420 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2421 (*i)->realtime_locate ();
2426 PluginInsert::monitoring_changed ()
2428 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2429 (*i)->monitoring_changed ();
2434 PluginInsert::start_touch (uint32_t param_id)
2436 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2438 ac->start_touch (session().audible_frame());
2443 PluginInsert::end_touch (uint32_t param_id)
2445 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2447 ac->stop_touch (true, session().audible_frame());
2451 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2454 case PluginInsert::Impossible: o << "Impossible"; break;
2455 case PluginInsert::Delegate: o << "Delegate"; break;
2456 case PluginInsert::NoInputs: o << "NoInputs"; break;
2457 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2458 case PluginInsert::Replicate: o << "Replicate"; break;
2459 case PluginInsert::Split: o << "Split"; break;
2460 case PluginInsert::Hide: o << "Hide"; break;
2462 o << " cnt: " << m.plugins
2463 << (m.strict_io ? " strict-io" : "")
2464 << (m.custom_cfg ? " custom-cfg" : "");
2465 if (m.method == PluginInsert::Hide) {
2466 o << " hide: " << m.hide;