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 ();
85 PluginInsert::~PluginInsert ()
90 PluginInsert::set_strict_io (bool b)
92 bool changed = _strict_io != b;
95 PluginConfigChanged (); /* EMIT SIGNAL */
100 PluginInsert::set_count (uint32_t num)
102 bool require_state = !_plugins.empty();
104 /* this is a bad idea.... we shouldn't do this while active.
105 only a route holding their redirect_lock should be calling this
110 } else if (num > _plugins.size()) {
111 uint32_t diff = num - _plugins.size();
113 for (uint32_t n = 0; n < diff; ++n) {
114 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
121 /* XXX do something */
124 PluginConfigChanged (); /* EMIT SIGNAL */
126 } else if (num < _plugins.size()) {
127 uint32_t diff = _plugins.size() - num;
128 for (uint32_t n= 0; n < diff; ++n) {
131 PluginConfigChanged (); /* EMIT SIGNAL */
139 PluginInsert::set_outputs (const ChanCount& c)
141 bool changed = (_custom_out != c) && _custom_cfg;
144 PluginConfigChanged (); /* EMIT SIGNAL */
149 PluginInsert::set_custom_cfg (bool b)
151 bool changed = _custom_cfg != b;
154 PluginConfigChanged (); /* EMIT SIGNAL */
159 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
161 if (which.type() != PluginAutomation)
164 boost::shared_ptr<AutomationControl> c
165 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
168 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
173 PluginInsert::output_streams() const
175 assert (_configured);
176 return _configured_out;
180 PluginInsert::input_streams() const
182 assert (_configured);
183 return _configured_in;
187 PluginInsert::internal_output_streams() const
189 assert (!_plugins.empty());
191 PluginInfoPtr info = _plugins.front()->get_info();
193 if (info->reconfigurable_io()) {
194 ChanCount out = _plugins.front()->output_streams ();
195 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
198 ChanCount out = info->n_outputs;
199 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
200 out.set_audio (out.n_audio() * _plugins.size());
201 out.set_midi (out.n_midi() * _plugins.size());
207 PluginInsert::internal_input_streams() const
209 assert (!_plugins.empty());
213 PluginInfoPtr info = _plugins.front()->get_info();
215 if (info->reconfigurable_io()) {
216 assert (_plugins.size() == 1);
217 in = _plugins.front()->input_streams();
222 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
224 if (_match.method == Split) {
226 /* we are splitting 1 processor input to multiple plugin inputs,
227 so we have a maximum of 1 stream of each type.
229 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
230 if (in.get (*t) > 1) {
236 } else if (_match.method == Hide) {
238 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
239 in.set (*t, in.get (*t) - _match.hide.get (*t));
245 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
246 in.set (*t, in.get (*t) * _plugins.size ());
254 PluginInsert::natural_output_streams() const
256 return _plugins[0]->get_info()->n_outputs;
260 PluginInsert::natural_input_streams() const
262 return _plugins[0]->get_info()->n_inputs;
266 PluginInsert::has_no_inputs() const
268 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
272 PluginInsert::has_no_audio_inputs() const
274 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
278 PluginInsert::is_midi_instrument() const
280 /* XXX more finesse is possible here. VST plugins have a
281 a specific "instrument" flag, for example.
283 PluginInfoPtr pi = _plugins[0]->get_info();
285 return pi->n_inputs.n_midi() != 0 &&
286 pi->n_outputs.n_audio() > 0;
290 PluginInsert::create_automatable_parameters ()
292 assert (!_plugins.empty());
294 set<Evoral::Parameter> a = _plugins.front()->automatable ();
296 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
297 if (i->type() == PluginAutomation) {
299 Evoral::Parameter param(*i);
301 ParameterDescriptor desc;
302 _plugins.front()->get_parameter_descriptor(i->id(), desc);
304 can_automate (param);
305 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
306 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
308 _plugins.front()->set_automation_control (i->id(), c);
309 } else if (i->type() == PluginPropertyAutomation) {
310 Evoral::Parameter param(*i);
311 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
312 if (desc.datatype != Variant::NOTHING) {
313 boost::shared_ptr<AutomationList> list;
314 if (Variant::type_is_numeric(desc.datatype)) {
315 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
317 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
322 /** Called when something outside of this host has modified a plugin
323 * parameter. Responsible for propagating the change to two places:
325 * 1) anything listening to the Control itself
326 * 2) any replicated plugins that make up this PluginInsert.
328 * The PluginInsert is connected to the ParameterChangedExternally signal for
329 * the first (primary) plugin, and here broadcasts that change to any others.
331 * XXX We should probably drop this whole replication idea (Paul, October 2015)
332 * since it isn't used by sensible plugin APIs (AU, LV2).
335 PluginInsert::parameter_changed_externally (uint32_t which, float val)
337 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
339 /* First propagation: alter the underlying value of the control,
340 * without telling the plugin(s) that own/use it to set it.
347 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
350 pc->catch_up_with_external_value (val);
353 /* Second propagation: tell all plugins except the first to
354 update the value of this parameter. For sane plugin APIs,
355 there are no other plugins, so this is a no-op in those
359 Plugins::iterator i = _plugins.begin();
361 /* don't set the first plugin, just all the slaves */
363 if (i != _plugins.end()) {
365 for (; i != _plugins.end(); ++i) {
366 (*i)->set_parameter (which, val);
372 PluginInsert::set_block_size (pframes_t nframes)
375 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
376 if ((*i)->set_block_size (nframes) != 0) {
384 PluginInsert::activate ()
386 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
390 Processor::activate ();
394 PluginInsert::deactivate ()
396 Processor::deactivate ();
398 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
404 PluginInsert::flush ()
406 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
412 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
414 PinMappings in_map (_in_map);
415 PinMappings out_map (_out_map);
418 // TODO optimize special case.
419 // Currently this never triggers because the in_map for "Split" triggeres no_inplace.
420 if (_match.method == Split && !_no_inplace) {
421 assert (in_map.size () == 1);
422 in_map[0] = ChanMapping (ChanCount::max (natural_input_streams (), _configured_in));
423 ChanCount const in_streams = internal_input_streams ();
424 /* copy the first stream's audio buffer contents to the others */
426 uint32_t first_idx = in_map[0].get (DataType::AUDIO, 0, &valid);
428 for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
429 uint32_t idx = in_map[0].get (DataType::AUDIO, i, &valid);
431 bufs.get_audio(idx).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
438 bufs.set_count(ChanCount::max(bufs.count(), _configured_in));
439 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
445 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
447 boost::shared_ptr<AutomationControl> c
448 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
450 if (c->list() && c->automation_playback()) {
453 const float val = c->list()->rt_safe_eval (now, valid);
456 /* This is the ONLY place where we are
458 * AutomationControl::set_value_unchecked(). We
459 * know that the control is in
460 * automation playback mode, so no
461 * check on writable() is required
462 * (which must be done in AutomationControl::set_value()
465 c->set_value_unchecked(val);
472 /* Calculate if, and how many frames we need to collect for analysis */
473 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
474 _signal_analysis_collected_nframes);
475 if (nframes < collect_signal_nframes) { // we might not get all frames now
476 collect_signal_nframes = nframes;
479 if (collect_signal_nframes > 0) {
481 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
482 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
483 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
485 _signal_analysis_inputs.set_count(internal_input_streams());
487 for (uint32_t i = 0; i < internal_input_streams().n_audio(); ++i) {
488 _signal_analysis_inputs.get_audio(i).read_from(
490 collect_signal_nframes,
491 _signal_analysis_collected_nframes); // offset is for target buffer
496 if (_plugins.front()->is_channelstrip() ) {
497 if (_configured_in.n_audio() > 0) {
498 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
499 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
501 _plugins.front()->connect_and_run (bufs, mb_in_map, mb_out_map, nframes, offset);
503 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
504 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
510 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
511 ARDOUR::ChanMapping used_outputs;
514 // TODO optimize this flow. prepare during configure_io()
515 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
517 ARDOUR::ChanMapping i_in_map (natural_input_streams());
518 ARDOUR::ChanMapping i_out_map;
519 ARDOUR::ChanCount mapped;
520 ARDOUR::ChanCount backmap;
522 // map inputs sequentially
523 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
524 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
526 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
527 uint32_t m = mapped.get (*t);
529 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
531 inplace_bufs.get (*t, m).silence (nframes, offset);
533 mapped.set (*t, m + 1);
537 // TODO use map_offset_to() instead ??
541 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
542 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
543 uint32_t m = mapped.get (*t);
544 inplace_bufs.get (*t, m).silence (nframes, offset);
545 i_out_map.set (*t, out, m);
546 mapped.set (*t, m + 1);
550 if ((*i)->connect_and_run(inplace_bufs, i_in_map, i_out_map, nframes, offset)) {
555 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
556 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
557 uint32_t m = backmap.get (*t);
559 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
561 bufs.get (*t, out_idx).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
562 used_outputs.set (*t, out_idx, 1); // mark as used
564 backmap.set (*t, m + 1);
568 /* all instances have completed, now clear outputs that have not been written to.
569 * (except midi bypass)
571 if (has_midi_bypass ()) {
572 used_outputs.set (DataType::MIDI, 0, 1); // Midi bypass.
574 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
575 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
577 used_outputs.get (*t, out, &valid);
578 if (valid) { continue; }
579 bufs.get (*t, out).silence (nframes, offset);
585 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
586 if ((*i)->connect_and_run(bufs, in_map[pc], out_map[pc], nframes, offset)) {
591 // TODO optimize: store "unconnected" in a fixed set.
592 // it only changes on reconfiguration.
593 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
594 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
596 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
597 mapped = true; // in-place Midi bypass
599 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
600 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
602 uint32_t idx = out_map[pc].get (*t, o, &valid);
603 if (valid && idx == out) {
610 bufs.get (*t, out).silence (nframes, offset);
616 if (collect_signal_nframes > 0) {
618 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
619 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
621 _signal_analysis_outputs.set_count(internal_output_streams());
623 for (uint32_t i = 0; i < internal_output_streams().n_audio(); ++i) {
624 _signal_analysis_outputs.get_audio(i).read_from(
626 collect_signal_nframes,
627 _signal_analysis_collected_nframes); // offset is for target buffer
630 _signal_analysis_collected_nframes += collect_signal_nframes;
631 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
633 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
634 _signal_analysis_collect_nframes_max = 0;
635 _signal_analysis_collected_nframes = 0;
637 AnalysisDataGathered(&_signal_analysis_inputs,
638 &_signal_analysis_outputs);
644 PluginInsert::silence (framecnt_t nframes)
650 ChanMapping in_map (natural_input_streams ());
651 ChanMapping out_map (natural_output_streams ());
653 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
654 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
659 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
661 if (_pending_active) {
662 /* run as normal if we are active or moving from inactive to active */
664 if (_session.transport_rolling() || _session.bounce_processing()) {
665 automation_run (bufs, start_frame, nframes);
667 connect_and_run (bufs, nframes, 0, false);
671 // TODO use mapping in bypassed mode ?!
672 // -> do we bypass the processor or the plugin
674 uint32_t in = input_streams ().n_audio ();
675 uint32_t out = output_streams().n_audio ();
677 if (has_no_audio_inputs() || in == 0) {
679 /* silence all (audio) outputs. Should really declick
680 * at the transitions of "active"
683 for (uint32_t n = 0; n < out; ++n) {
684 bufs.get_audio (n).silence (nframes);
687 } else if (out > in) {
689 /* not active, but something has make up for any channel count increase
690 * for now , simply replicate last buffer
692 for (uint32_t n = in; n < out; ++n) {
693 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
697 bufs.count().set_audio (out);
700 _active = _pending_active;
702 /* we have no idea whether the plugin generated silence or not, so mark
703 * all buffers appropriately.
708 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
710 Evoral::ControlEvent next_event (0, 0.0f);
711 framepos_t now = start;
712 framepos_t end = now + nframes;
713 framecnt_t offset = 0;
715 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
718 connect_and_run (bufs, nframes, offset, false);
722 if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
724 /* no events have a time within the relevant range */
726 connect_and_run (bufs, nframes, offset, true, now);
732 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
734 connect_and_run (bufs, cnt, offset, true, now);
740 if (!find_next_event (now, end, next_event)) {
745 /* cleanup anything that is left to do */
748 connect_and_run (bufs, nframes, offset, true, now);
753 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
755 if (param.type() != PluginAutomation)
758 if (_plugins.empty()) {
759 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
761 abort(); /*NOTREACHED*/
764 return _plugins[0]->default_value (param.id());
769 PluginInsert::can_reset_all_parameters ()
773 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
775 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
777 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
781 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
787 if (ac->automation_state() & Play) {
792 return all && (params > 0);
796 PluginInsert::reset_parameters_to_default ()
800 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
802 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
804 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
808 const float dflt = _plugins[0]->default_value (cid);
809 const float curr = _plugins[0]->get_parameter (cid);
815 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
820 if (ac->automation_state() & Play) {
825 ac->set_value (dflt, Controllable::NoGroup);
830 boost::shared_ptr<Plugin>
831 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
833 boost::shared_ptr<LadspaPlugin> lp;
834 boost::shared_ptr<LuaProc> lua;
836 boost::shared_ptr<LV2Plugin> lv2p;
838 #ifdef WINDOWS_VST_SUPPORT
839 boost::shared_ptr<WindowsVSTPlugin> vp;
842 boost::shared_ptr<LXVSTPlugin> lxvp;
844 #ifdef AUDIOUNIT_SUPPORT
845 boost::shared_ptr<AUPlugin> ap;
848 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
849 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
850 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
851 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
853 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
854 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
856 #ifdef WINDOWS_VST_SUPPORT
857 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
858 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
861 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
862 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
864 #ifdef AUDIOUNIT_SUPPORT
865 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
866 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
870 fatal << string_compose (_("programming error: %1"),
871 X_("unknown plugin type in PluginInsert::plugin_factory"))
873 abort(); /*NOTREACHED*/
874 return boost::shared_ptr<Plugin> ((Plugin*) 0);
878 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
879 if (num < _in_map.size()) {
880 bool changed = _in_map[num] != m;
884 PluginMapChanged (); /* EMIT SIGNAL */
890 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
891 if (num < _out_map.size()) {
892 bool changed = _out_map[num] != m;
896 PluginMapChanged (); /* EMIT SIGNAL */
902 PluginInsert::input_map () const
906 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
907 ChanMapping m (i->second);
908 const ChanMapping::Mappings& mp ((*i).second.mappings());
909 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
910 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
911 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
919 PluginInsert::output_map () const
923 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
924 ChanMapping m (i->second);
925 const ChanMapping::Mappings& mp ((*i).second.mappings());
926 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
927 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
928 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
932 if (has_midi_bypass ()) {
933 rv.set (DataType::MIDI, 0, 0);
940 PluginInsert::has_midi_bypass () const
942 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1 && natural_output_streams ().n_midi () == 0) {
949 PluginInsert::sanitize_maps ()
951 bool changed = false;
952 /* strip dead wood */
954 PinMappings new_outs;
955 for (uint32_t pc = 0; pc < get_count(); ++pc) {
958 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
959 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
961 uint32_t idx = _in_map[pc].get (*t, i, &valid);
962 if (valid && idx <= _configured_in.get (*t)) {
963 new_in.set (*t, i, idx);
966 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
968 uint32_t idx = _out_map[pc].get (*t, o, &valid);
969 if (valid && idx <= _configured_out.get (*t)) {
970 new_out.set (*t, o, idx);
974 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
977 new_ins[pc] = new_in;
978 new_outs[pc] = new_out;
980 /* prevent dup output assignments */
981 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
982 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
984 for (uint32_t pc = 0; pc < get_count(); ++pc) {
986 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
987 if (valid && mapped) {
988 new_outs[pc].unset (*t, idx);
996 if (_in_map != new_ins || _out_map != new_outs) {
1000 _out_map = new_outs;
1006 PluginInsert::reset_map (bool emit)
1009 const PinMappings old_in (_in_map);
1010 const PinMappings old_out (_out_map);
1014 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1015 if (_match.method == Split) {
1016 _in_map[pc] = ChanMapping ();
1017 /* connect inputs in round-robin fashion */
1018 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1019 const uint32_t cend = _configured_in.get (*t);
1020 if (cend == 0) { continue; }
1022 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
1023 _in_map[pc].set (*t, in, c);
1028 _in_map[pc] = ChanMapping (ChanCount::min (natural_input_streams (), _configured_in));
1030 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1032 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1033 _in_map[pc].offset_to(*t, pc * natural_input_streams().get(*t));
1034 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1037 if (old_in == _in_map && old_out == _out_map) {
1041 PluginMapChanged (); /* EMIT SIGNAL */
1047 PluginInsert::configure_io (ChanCount in, ChanCount out)
1049 Match old_match = _match;
1054 old_in = _configured_in;
1055 old_out = _configured_out;
1058 _configured_in = in;
1059 _configured_out = out;
1061 /* get plugin configuration */
1062 _match = private_can_support_io_configuration (in, out);
1064 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1066 DEBUG_STR_APPEND(a, string_compose ("Match '%1':", name()));
1067 DEBUG_STR_APPEND(a, _match);
1068 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1072 /* set the matching method and number of plugins that we will use to meet this configuration */
1073 if (set_count (_match.plugins) == false) {
1074 PluginIoReConfigure (); /* EMIT SIGNAL */
1075 _configured = false;
1079 /* configure plugins */
1080 switch (_match.method) {
1083 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1084 PluginIoReConfigure (); /* EMIT SIGNAL */
1085 _configured = false;
1093 bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1095 assert (_match.strict_io || dout.n_audio() == out.n_audio()); // sans midi bypass
1096 if (useins.n_audio() == 0) {
1099 if (_plugins.front()->configure_io (useins, dout) == false) {
1100 PluginIoReConfigure (); /* EMIT SIGNAL */
1101 _configured = false;
1107 if (_plugins.front()->configure_io (in, out) == false) {
1108 PluginIoReConfigure (); /* EMIT SIGNAL */
1109 _configured = false;
1115 bool mapping_changed = false;
1116 if (old_in == in && old_out == out && _configured
1117 && old_match.method == _match.method
1118 && _in_map.size() == _out_map.size()
1119 && _in_map.size() == get_count ()
1121 /* If the configuraton has not changed, keep the mapping */
1122 } else if (_match.custom_cfg && _configured) {
1123 mapping_changed = sanitize_maps ();
1125 if (_maps_from_state) {
1126 _maps_from_state = false;
1127 mapping_changed = true;
1130 /* generate a new mapping */
1131 mapping_changed = reset_map (false);
1135 if (mapping_changed) {
1136 PluginMapChanged (); /* EMIT SIGNAL */
1139 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1142 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1143 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1145 DEBUG_STR_APPEND(a, "----><----\n");
1147 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1148 DEBUG_STR_APPEND(a, " * Inputs:\n");
1149 DEBUG_STR_APPEND(a, _in_map[pc]);
1150 DEBUG_STR_APPEND(a, " * Outputs:\n");
1151 DEBUG_STR_APPEND(a, _out_map[pc]);
1153 DEBUG_STR_APPEND(a, "-------->>--------\n");
1154 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1159 // auto-detect if inplace processing is possible
1160 bool inplace_ok = true;
1161 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1162 if (!_in_map[pc].is_monotonic ()) {
1165 if (!_out_map[pc].is_monotonic ()) {
1169 _no_inplace = !inplace_ok || _plugins.front()->inplace_broken ();
1171 if (old_in != in || old_out != out
1172 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1174 PluginIoReConfigure (); /* EMIT SIGNAL */
1177 // we don't know the analysis window size, so we must work with the
1178 // current buffer size here. each request for data fills in these
1179 // buffers and the analyser makes sure it gets enough data for the
1181 session().ensure_buffer_set (_signal_analysis_inputs, in);
1182 //_signal_analysis_inputs.set_count (in);
1184 session().ensure_buffer_set (_signal_analysis_outputs, out);
1185 //_signal_analysis_outputs.set_count (out);
1187 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1190 return Processor::configure_io (in, out);
1193 /** Decide whether this PluginInsert can support a given IO configuration.
1194 * To do this, we run through a set of possible solutions in rough order of
1197 * @param in Required input channel count.
1198 * @param out Filled in with the output channel count if we return true.
1199 * @return true if the given IO configuration can be supported.
1202 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1204 return private_can_support_io_configuration (in, out).method != Impossible;
1207 /** A private version of can_support_io_configuration which returns the method
1208 * by which the configuration can be matched, rather than just whether or not
1212 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1214 if (_plugins.empty()) {
1218 /* if a user specified a custom cfg, so be it. */
1221 return Match (ExactMatch, get_count(), false, true); // XXX
1224 /* try automatic configuration */
1225 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1227 PluginInfoPtr info = _plugins.front()->get_info();
1228 ChanCount inputs = info->n_inputs;
1229 ChanCount outputs = info->n_outputs;
1230 ChanCount midi_bypass;
1231 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1232 midi_bypass.set (DataType::MIDI, 1);
1235 /* handle case strict-i/o */
1236 if (_strict_io && m.method != Impossible) {
1239 /* special case MIDI instruments */
1240 if (is_midi_instrument()) {
1241 // output = midi-bypass + at most master-out channels.
1242 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1243 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1244 out = ChanCount::min (out, max_out);
1250 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1251 /* replicate processor to match output count (generators and such)
1252 * at least enough to feed every output port. */
1253 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1254 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1255 uint32_t nin = inputs.get (*t);
1256 if (nin == 0 || inx.get(*t) == 0) { continue; }
1257 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1259 out = inx + midi_bypass;
1260 return Match (Replicate, f);
1269 out = inx + midi_bypass;
1270 if (inx.get(DataType::MIDI) == 1
1271 && out.get (DataType::MIDI) == 0
1272 && outputs.get(DataType::MIDI) == 0) {
1273 out += ChanCount (DataType::MIDI, 1);
1278 if (m.method != Impossible) {
1282 if (info->reconfigurable_io()) {
1284 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1286 // houston, we have a problem.
1287 return Match (Impossible, 0);
1289 return Match (Delegate, 1);
1292 // add at least as many plugins so that output count matches input count
1294 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1295 uint32_t nin = inputs.get (*t);
1296 uint32_t nout = outputs.get (*t);
1297 if (nin == 0 || inx.get(*t) == 0) { continue; }
1298 // prefer floor() so the count won't overly increase IFF (nin < nout)
1299 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1301 if (f > 0 && outputs * f >= _configured_out) {
1302 out = outputs * f + midi_bypass;
1303 return Match (Replicate, f);
1306 // add at least as many plugins needed to connect all inputs
1308 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1309 uint32_t nin = inputs.get (*t);
1310 if (nin == 0 || inx.get(*t) == 0) { continue; }
1311 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1313 out = outputs * f + midi_bypass;
1314 return Match (Replicate, f);
1317 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1319 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1321 if (_plugins.empty()) {
1325 PluginInfoPtr info = _plugins.front()->get_info();
1326 ChanCount in; in += inx;
1327 ChanCount midi_bypass;
1329 if (info->reconfigurable_io()) {
1330 /* Plugin has flexible I/O, so delegate to it */
1331 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1333 return Match (Impossible, 0);
1335 return Match (Delegate, 1);
1338 ChanCount inputs = info->n_inputs;
1339 ChanCount outputs = info->n_outputs;
1341 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1342 DEBUG_TRACE ( DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1343 midi_bypass.set (DataType::MIDI, 1);
1345 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1346 DEBUG_TRACE ( DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1347 in.set(DataType::MIDI, 0);
1350 bool no_inputs = true;
1351 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1352 if (inputs.get (*t) != 0) {
1359 /* no inputs so we can take any input configuration since we throw it away */
1360 out = outputs + midi_bypass;
1361 return Match (NoInputs, 1);
1364 /* Plugin inputs match requested inputs exactly */
1366 out = outputs + midi_bypass;
1367 return Match (ExactMatch, 1);
1370 /* We may be able to run more than one copy of the plugin within this insert
1371 to cope with the insert having more inputs than the plugin.
1372 We allow replication only for plugins with either zero or 1 inputs and outputs
1373 for every valid data type.
1377 bool can_replicate = true;
1378 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1380 uint32_t nin = inputs.get (*t);
1382 // No inputs of this type
1383 if (nin == 0 && in.get(*t) == 0) {
1387 if (nin != 1 || outputs.get (*t) != 1) {
1388 can_replicate = false;
1392 // Potential factor not set yet
1394 f = in.get(*t) / nin;
1397 // Factor for this type does not match another type, can not replicate
1398 if (f != (in.get(*t) / nin)) {
1399 can_replicate = false;
1404 if (can_replicate && f > 0) {
1405 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1406 out.set (*t, outputs.get(*t) * f);
1409 return Match (Replicate, f);
1412 /* If the processor has exactly one input of a given type, and
1413 the plugin has more, we can feed the single processor input
1414 to some or all of the plugin inputs. This is rather
1415 special-case-y, but the 1-to-many case is by far the
1416 simplest. How do I split thy 2 processor inputs to 3
1417 plugin inputs? Let me count the ways ...
1420 bool can_split = true;
1421 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1423 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
1424 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1426 if (!can_split_type && !nothing_to_do_for_type) {
1432 out = outputs + midi_bypass;
1433 return Match (Split, 1);
1436 /* If the plugin has more inputs than we want, we can `hide' some of them
1437 by feeding them silence.
1440 bool could_hide = false;
1441 bool cannot_hide = false;
1442 ChanCount hide_channels;
1444 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1445 if (inputs.get(*t) > in.get(*t)) {
1446 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1447 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1449 } else if (inputs.get(*t) < in.get(*t)) {
1450 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1455 if (could_hide && !cannot_hide) {
1456 out = outputs + midi_bypass;
1457 return Match (Hide, 1, false, false, hide_channels);
1460 return Match (Impossible, 0);
1465 PluginInsert::get_state ()
1467 return state (true);
1471 PluginInsert::state (bool full)
1473 XMLNode& node = Processor::state (full);
1475 node.add_property("type", _plugins[0]->state_node_name());
1476 node.add_property("unique-id", _plugins[0]->unique_id());
1477 node.add_property("count", string_compose("%1", _plugins.size()));
1479 /* remember actual i/o configuration (for later placeholder
1480 * in case the plugin goes missing) */
1481 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1482 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1484 /* save custom i/o config */
1485 node.add_property("custom", _custom_cfg ? "yes" : "no");
1486 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1488 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1489 node.add_child_nocopy (* _in_map[pc].state (tmp));
1490 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1491 node.add_child_nocopy (* _out_map[pc].state (tmp));
1494 _plugins[0]->set_insert_id(this->id());
1495 node.add_child_nocopy (_plugins[0]->get_state());
1497 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1498 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1500 node.add_child_nocopy (ac->get_state());
1508 PluginInsert::set_control_ids (const XMLNode& node, int version)
1510 const XMLNodeList& nlist = node.children();
1511 XMLNodeConstIterator iter;
1512 set<Evoral::Parameter>::const_iterator p;
1514 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1515 if ((*iter)->name() == Controllable::xml_node_name) {
1516 const XMLProperty* prop;
1518 uint32_t p = (uint32_t)-1;
1520 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1521 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1523 p = lv2plugin->port_index(prop->value().c_str());
1527 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1528 p = atoi (prop->value());
1531 if (p != (uint32_t)-1) {
1533 /* this may create the new controllable */
1535 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1537 #ifndef NO_PLUGIN_STATE
1541 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1543 ac->set_state (**iter, version);
1552 PluginInsert::set_state(const XMLNode& node, int version)
1554 XMLNodeList nlist = node.children();
1555 XMLNodeIterator niter;
1556 XMLPropertyList plist;
1557 const XMLProperty *prop;
1558 ARDOUR::PluginType type;
1560 if ((prop = node.property ("type")) == 0) {
1561 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1565 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1566 type = ARDOUR::LADSPA;
1567 } else if (prop->value() == X_("lv2")) {
1569 } else if (prop->value() == X_("windows-vst")) {
1570 type = ARDOUR::Windows_VST;
1571 } else if (prop->value() == X_("lxvst")) {
1572 type = ARDOUR::LXVST;
1573 } else if (prop->value() == X_("audiounit")) {
1574 type = ARDOUR::AudioUnit;
1575 } else if (prop->value() == X_("luaproc")) {
1578 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1584 prop = node.property ("unique-id");
1587 #ifdef WINDOWS_VST_SUPPORT
1588 /* older sessions contain VST plugins with only an "id" field.
1591 if (type == ARDOUR::Windows_VST) {
1592 prop = node.property ("id");
1596 #ifdef LXVST_SUPPORT
1597 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1599 if (type == ARDOUR::LXVST) {
1600 prop = node.property ("id");
1606 error << _("Plugin has no unique ID field") << endmsg;
1611 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1613 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1614 * allow to move sessions windows <> linux */
1615 #ifdef LXVST_SUPPORT
1616 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1617 type = ARDOUR::LXVST;
1618 plugin = find_plugin (_session, prop->value(), type);
1622 #ifdef WINDOWS_VST_SUPPORT
1623 if (plugin == 0 && type == ARDOUR::LXVST) {
1624 type = ARDOUR::Windows_VST;
1625 plugin = find_plugin (_session, prop->value(), type);
1630 error << string_compose(
1631 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1632 "Perhaps it was removed or moved since it was last used."),
1638 if (type == ARDOUR::Lua) {
1639 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1640 // we need to load the script to set the name and parameters.
1641 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1643 lp->set_script_from_state (*ls);
1647 // The name of the PluginInsert comes from the plugin, nothing else
1648 _name = plugin->get_info()->name;
1652 // Processor::set_state() will set this, but too late
1653 // for it to be available when setting up plugin
1654 // state. We can't call Processor::set_state() until
1655 // the plugins themselves are created and added.
1659 if (_plugins.empty()) {
1660 /* if we are adding the first plugin, we will need to set
1661 up automatable controls.
1663 add_plugin (plugin);
1664 create_automatable_parameters ();
1665 set_control_ids (node, version);
1668 if ((prop = node.property ("count")) != 0) {
1669 sscanf (prop->value().c_str(), "%u", &count);
1672 if (_plugins.size() != count) {
1673 for (uint32_t n = 1; n < count; ++n) {
1674 add_plugin (plugin_factory (plugin));
1678 Processor::set_state (node, version);
1680 PBD::ID new_id = this->id();
1681 PBD::ID old_id = this->id();
1683 if ((prop = node.property ("id")) != 0) {
1684 old_id = prop->value ();
1687 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1689 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1690 and set all plugins to the same state.
1693 if ((*niter)->name() == plugin->state_node_name()) {
1695 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1696 /* Plugin state can include external files which are named after the ID.
1698 * If regenerate_xml_or_string_ids() is set, the ID will already have
1699 * been changed, so we need to use the old ID from the XML to load the
1700 * state and then update the ID.
1702 * When copying a plugin-state, route_ui takes care of of updating the ID,
1703 * but we need to call set_insert_id() to clear the cached plugin-state
1704 * and force a change.
1706 if (!regenerate_xml_or_string_ids ()) {
1707 (*i)->set_insert_id (new_id);
1709 (*i)->set_insert_id (old_id);
1712 (*i)->set_state (**niter, version);
1714 if (regenerate_xml_or_string_ids ()) {
1715 (*i)->set_insert_id (new_id);
1723 if (version < 3000) {
1725 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1726 this is all handled by Automatable
1729 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1730 if ((*niter)->name() == "Redirect") {
1731 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1732 Processor::set_state (**niter, version);
1737 set_parameter_state_2X (node, version);
1740 if ((prop = node.property (X_("custom"))) != 0) {
1741 _custom_cfg = string_is_affirmative (prop->value());
1744 uint32_t in_maps = 0;
1745 uint32_t out_maps = 0;
1746 XMLNodeList kids = node.children ();
1747 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
1748 if ((*i)->name() == X_("ConfiguredOutput")) {
1749 _custom_out = ChanCount(**i);
1751 if (strncmp ((*i)->name().c_str(), X_("InputMap-"), 9) == 0) {
1752 long pc = atol (&((*i)->name().c_str()[9]));
1753 if (pc >=0 && pc <= get_count()) {
1754 _in_map[pc] = ChanMapping (**i);
1758 if (strncmp ((*i)->name().c_str(), X_("OutputMap-"), 10) == 0) {
1759 long pc = atol (&((*i)->name().c_str()[10]));
1760 if (pc >=0 && pc <= get_count()) {
1761 _out_map[pc] = ChanMapping (**i);
1766 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
1767 _maps_from_state = true;
1770 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1774 (*i)->deactivate ();
1782 PluginInsert::update_id (PBD::ID id)
1785 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1786 (*i)->set_insert_id (id);
1791 PluginInsert::set_state_dir (const std::string& d)
1793 // state() only saves the state of the first plugin
1794 _plugins[0]->set_state_dir (d);
1798 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1800 XMLNodeList nlist = node.children();
1801 XMLNodeIterator niter;
1803 /* look for port automation node */
1805 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1807 if ((*niter)->name() != port_automation_node_name) {
1813 XMLNodeConstIterator iter;
1818 cnodes = (*niter)->children ("port");
1820 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1824 if ((cprop = child->property("number")) != 0) {
1825 port = cprop->value().c_str();
1827 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1831 sscanf (port, "%" PRIu32, &port_id);
1833 if (port_id >= _plugins[0]->parameter_count()) {
1834 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1838 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1839 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1841 if (c && c->alist()) {
1842 if (!child->children().empty()) {
1843 c->alist()->set_state (*child->children().front(), version);
1845 /* In some cases 2.X saves lists with min_yval and max_yval
1846 being FLT_MIN and FLT_MAX respectively. This causes problems
1847 in A3 because these min/max values are used to compute
1848 where GUI control points should be drawn. If we see such
1849 values, `correct' them to the min/max of the appropriate
1853 float min_y = c->alist()->get_min_y ();
1854 float max_y = c->alist()->get_max_y ();
1856 ParameterDescriptor desc;
1857 _plugins.front()->get_parameter_descriptor (port_id, desc);
1859 if (min_y == FLT_MIN) {
1863 if (max_y == FLT_MAX) {
1867 c->alist()->set_yrange (min_y, max_y);
1870 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1882 PluginInsert::describe_parameter (Evoral::Parameter param)
1884 if (param.type() == PluginAutomation) {
1885 return _plugins[0]->describe_parameter (param);
1886 } else if (param.type() == PluginPropertyAutomation) {
1887 boost::shared_ptr<AutomationControl> c(automation_control(param));
1888 if (c && !c->desc().label.empty()) {
1889 return c->desc().label;
1892 return Automatable::describe_parameter(param);
1896 PluginInsert::signal_latency() const
1898 if (_user_latency) {
1899 return _user_latency;
1902 return _plugins[0]->signal_latency ();
1906 PluginInsert::type ()
1908 return plugin()->get_info()->type;
1911 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1912 const Evoral::Parameter& param,
1913 const ParameterDescriptor& desc,
1914 boost::shared_ptr<AutomationList> list)
1915 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1919 alist()->reset_default (desc.normal);
1921 list->set_interpolation(Evoral::ControlList::Discrete);
1926 set_flags(Controllable::Toggle);
1930 /** @param val `user' value */
1932 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1935 _set_value (user_val, group_override);
1939 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1941 /* used only by automation playback */
1942 _set_value (user_val, Controllable::NoGroup);
1946 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1948 /* FIXME: probably should be taking out some lock here.. */
1950 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1951 (*i)->set_parameter (_list->parameter().id(), user_val);
1954 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1956 iasp->set_parameter (_list->parameter().id(), user_val);
1959 AutomationControl::set_value (user_val, group_override);
1963 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1965 AutomationControl::set_value (user_val, Controllable::NoGroup);
1969 PluginInsert::PluginControl::get_state ()
1973 XMLNode& node (AutomationControl::get_state());
1974 ss << parameter().id();
1975 node.add_property (X_("parameter"), ss.str());
1977 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1979 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1986 /** @return `user' val */
1988 PluginInsert::PluginControl::get_value () const
1990 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1996 return plugin->get_parameter (_list->parameter().id());
1999 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2000 const Evoral::Parameter& param,
2001 const ParameterDescriptor& desc,
2002 boost::shared_ptr<AutomationList> list)
2003 : AutomationControl (p->session(), param, desc, list)
2007 alist()->set_yrange (desc.lower, desc.upper);
2008 alist()->reset_default (desc.normal);
2012 set_flags(Controllable::Toggle);
2017 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2020 set_value_unchecked (user_val);
2025 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2027 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2028 This is lossy, but better than nothing until Ardour's automation system
2029 can handle various datatypes all the way down. */
2030 const Variant value(_desc.datatype, user_val);
2031 if (value.type() == Variant::NOTHING) {
2032 error << "set_value(double) called for non-numeric property" << endmsg;
2036 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2037 (*i)->set_property(_list->parameter().id(), value);
2041 AutomationControl::set_value (user_val, Controllable::NoGroup);
2045 PluginInsert::PluginPropertyControl::get_state ()
2049 XMLNode& node (AutomationControl::get_state());
2050 ss << parameter().id();
2051 node.add_property (X_("property"), ss.str());
2052 node.remove_property (X_("value"));
2058 PluginInsert::PluginPropertyControl::get_value () const
2060 return _value.to_double();
2063 boost::shared_ptr<Plugin>
2064 PluginInsert::get_impulse_analysis_plugin()
2066 boost::shared_ptr<Plugin> ret;
2067 if (_impulseAnalysisPlugin.expired()) {
2068 ret = plugin_factory(_plugins[0]);
2069 ret->configure_io (internal_input_streams (), internal_output_streams ());
2070 _impulseAnalysisPlugin = ret;
2072 ret = _impulseAnalysisPlugin.lock();
2079 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2081 // called from outside the audio thread, so this should be safe
2082 // only do audio as analysis is (currently) only for audio plugins
2083 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, internal_input_streams().n_audio(), nframes);
2084 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2086 _signal_analysis_collected_nframes = 0;
2087 _signal_analysis_collect_nframes_max = nframes;
2090 /** Add a plugin to our list */
2092 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2094 plugin->set_insert_id (this->id());
2096 if (_plugins.empty()) {
2097 /* first (and probably only) plugin instance - connect to relevant signals
2100 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2101 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2102 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2105 _plugins.push_back (plugin);
2109 PluginInsert::realtime_handle_transport_stopped ()
2111 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2112 (*i)->realtime_handle_transport_stopped ();
2117 PluginInsert::realtime_locate ()
2119 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2120 (*i)->realtime_locate ();
2125 PluginInsert::monitoring_changed ()
2127 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2128 (*i)->monitoring_changed ();
2133 PluginInsert::start_touch (uint32_t param_id)
2135 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2137 ac->start_touch (session().audible_frame());
2142 PluginInsert::end_touch (uint32_t param_id)
2144 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2146 ac->stop_touch (true, session().audible_frame());
2150 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2153 case PluginInsert::Impossible: o << "Impossible"; break;
2154 case PluginInsert::Delegate: o << "Delegate"; break;
2155 case PluginInsert::NoInputs: o << "NoInputs"; break;
2156 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2157 case PluginInsert::Replicate: o << "Replicate"; break;
2158 case PluginInsert::Split: o << "Split"; break;
2159 case PluginInsert::Hide: o << "Hide"; break;
2161 o << " cnt: " << m.plugins
2162 << (m.strict_io ? " strict-io" : "")
2163 << (m.custom_cfg ? " custom-cfg" : "");
2164 if (m.method == PluginInsert::Hide) {
2165 o << " hide: " << m.hide;