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;
883 PluginMapChanged (); /* EMIT SIGNAL */
889 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
890 if (num < _out_map.size()) {
891 bool changed = _out_map[num] != m;
894 PluginMapChanged (); /* EMIT SIGNAL */
900 PluginInsert::input_map () const
904 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
905 ChanMapping m (i->second);
906 const ChanMapping::Mappings& mp ((*i).second.mappings());
907 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
908 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
909 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
917 PluginInsert::output_map () const
921 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
922 ChanMapping m (i->second);
923 const ChanMapping::Mappings& mp ((*i).second.mappings());
924 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
925 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
926 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
930 if (has_midi_bypass ()) {
931 rv.set (DataType::MIDI, 0, 0);
938 PluginInsert::has_midi_bypass () const
940 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1 && natural_output_streams ().n_midi () == 0) {
947 PluginInsert::reset_map (bool emit)
950 const PinMappings old_in (_in_map);
951 const PinMappings old_out (_out_map);
955 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
956 if (_match.method == Split) {
957 _in_map[pc] = ChanMapping ();
958 /* connect inputs in round-robin fashion */
959 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
960 const uint32_t cend = _configured_in.get (*t);
961 if (cend == 0) { continue; }
963 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
964 _in_map[pc].set (*t, in, c);
969 _in_map[pc] = ChanMapping (ChanCount::min (natural_input_streams (), _configured_in));
971 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
973 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
974 _in_map[pc].offset_to(*t, pc * natural_input_streams().get(*t));
975 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
978 if (old_in == _in_map && old_out == _out_map) {
982 PluginMapChanged (); /* EMIT SIGNAL */
988 PluginInsert::configure_io (ChanCount in, ChanCount out)
990 Match old_match = _match;
995 old_in = _configured_in;
996 old_out = _configured_out;
1000 _configured_out = out;
1002 /* get plugin configuration */
1003 _match = private_can_support_io_configuration (in, out);
1004 #ifndef NDEBUG // XXX
1005 cout << "Match '" << name() << "': " << _match;
1008 /* set the matching method and number of plugins that we will use to meet this configuration */
1009 if (set_count (_match.plugins) == false) {
1010 PluginIoReConfigure (); /* EMIT SIGNAL */
1011 _configured = false;
1015 /* configure plugins */
1016 switch (_match.method) {
1019 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1020 PluginIoReConfigure (); /* EMIT SIGNAL */
1021 _configured = false;
1029 bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1031 assert (_match.strict_io || dout.n_audio() == out.n_audio()); // sans midi bypass
1032 if (useins.n_audio() == 0) {
1035 if (_plugins.front()->configure_io (useins, dout) == false) {
1036 PluginIoReConfigure (); /* EMIT SIGNAL */
1037 _configured = false;
1043 if (_plugins.front()->configure_io (in, out) == false) {
1044 PluginIoReConfigure (); /* EMIT SIGNAL */
1045 _configured = false;
1051 bool mapping_changed = false;
1052 if (old_in == in && old_out == out && _configured
1053 && old_match.method == _match.method
1054 && _in_map.size() == _out_map.size()
1055 && _in_map.size() == get_count ()
1057 /* If the configuraton has not changed, keep the mapping */
1058 } else if (_match.custom_cfg && _configured) {
1059 /* strip dead wood */
1060 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1062 ChanMapping new_out;
1063 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1064 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1066 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1067 if (valid && idx <= in.get (*t)) {
1068 new_in.set (*t, i, idx);
1071 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1073 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1074 if (valid && idx <= out.get (*t)) {
1075 new_out.set (*t, o, idx);
1079 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1080 mapping_changed = true;
1082 _in_map[pc] = new_in;
1083 _out_map[pc] = new_out;
1086 if (_maps_from_state) {
1087 _maps_from_state = false;
1088 mapping_changed = true;
1090 /* generate a new mapping */
1091 mapping_changed = reset_map (false);
1095 if (mapping_changed) {
1096 PluginMapChanged (); /* EMIT SIGNAL */
1097 #ifndef NDEBUG // XXX
1099 cout << "----<<----\n";
1100 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1101 cout << "Channel Map for " << name() << " plugin " << pc << "\n";
1102 cout << " * Inputs:\n" << _in_map[pc];
1103 cout << " * Outputs:\n" << _out_map[pc];
1105 cout << "---->>----\n";
1109 // auto-detect if inplace processing is possible
1110 bool inplace_ok = true;
1111 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1112 if (!_in_map[pc].is_monotonic ()) {
1115 if (!_out_map[pc].is_monotonic ()) {
1119 _no_inplace = !inplace_ok || _plugins.front()->inplace_broken ();
1121 if (old_in != in || old_out != out
1122 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1124 PluginIoReConfigure (); /* EMIT SIGNAL */
1127 // we don't know the analysis window size, so we must work with the
1128 // current buffer size here. each request for data fills in these
1129 // buffers and the analyser makes sure it gets enough data for the
1131 session().ensure_buffer_set (_signal_analysis_inputs, in);
1132 //_signal_analysis_inputs.set_count (in);
1134 session().ensure_buffer_set (_signal_analysis_outputs, out);
1135 //_signal_analysis_outputs.set_count (out);
1137 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1140 return Processor::configure_io (in, out);
1143 /** Decide whether this PluginInsert can support a given IO configuration.
1144 * To do this, we run through a set of possible solutions in rough order of
1147 * @param in Required input channel count.
1148 * @param out Filled in with the output channel count if we return true.
1149 * @return true if the given IO configuration can be supported.
1152 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1154 return private_can_support_io_configuration (in, out).method != Impossible;
1157 /** A private version of can_support_io_configuration which returns the method
1158 * by which the configuration can be matched, rather than just whether or not
1162 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1164 if (_plugins.empty()) {
1168 /* if a user specified a custom cfg, so be it. */
1171 return Match (ExactMatch, get_count(), false, true); // XXX
1174 /* try automatic configuration */
1175 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1177 PluginInfoPtr info = _plugins.front()->get_info();
1178 ChanCount inputs = info->n_inputs;
1179 ChanCount outputs = info->n_outputs;
1180 ChanCount midi_bypass;
1181 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1182 midi_bypass.set (DataType::MIDI, 1);
1185 /* handle case strict-i/o */
1186 if (_strict_io && m.method != Impossible) {
1189 /* special case MIDI instruments */
1190 if (is_midi_instrument()) {
1191 // output = midi-bypass + at most master-out channels.
1192 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1193 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1194 out = ChanCount::min (out, max_out);
1200 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1201 /* replicate processor to match output count (generators and such)
1202 * at least enough to feed every output port. */
1203 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1204 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1205 uint32_t nin = inputs.get (*t);
1206 if (nin == 0 || inx.get(*t) == 0) { continue; }
1207 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1209 out = inx + midi_bypass;
1210 return Match (Replicate, f);
1219 out = inx + midi_bypass;
1220 if (inx.get(DataType::MIDI) == 1
1221 && out.get (DataType::MIDI) == 0
1222 && outputs.get(DataType::MIDI) == 0) {
1223 out += ChanCount (DataType::MIDI, 1);
1228 if (m.method != Impossible) {
1232 if (info->reconfigurable_io()) {
1234 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1236 // houston, we have a problem.
1237 return Match (Impossible, 0);
1239 return Match (Delegate, 1);
1242 // add at least as many plugins so that output count matches input count
1244 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1245 uint32_t nin = inputs.get (*t);
1246 uint32_t nout = outputs.get (*t);
1247 if (nin == 0 || inx.get(*t) == 0) { continue; }
1248 // prefer floor() so the count won't overly increase IFF (nin < nout)
1249 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1251 if (f > 0 && outputs * f >= _configured_out) {
1252 out = outputs * f + midi_bypass;
1253 return Match (Replicate, f);
1256 // add at least as many plugins needed to connect all inputs
1258 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1259 uint32_t nin = inputs.get (*t);
1260 if (nin == 0 || inx.get(*t) == 0) { continue; }
1261 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1263 out = outputs * f + midi_bypass;
1264 return Match (Replicate, f);
1267 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1269 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1271 if (_plugins.empty()) {
1275 PluginInfoPtr info = _plugins.front()->get_info();
1276 ChanCount in; in += inx;
1277 ChanCount midi_bypass;
1279 if (info->reconfigurable_io()) {
1280 /* Plugin has flexible I/O, so delegate to it */
1281 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1283 return Match (Impossible, 0);
1285 return Match (Delegate, 1);
1288 ChanCount inputs = info->n_inputs;
1289 ChanCount outputs = info->n_outputs;
1291 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1292 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
1293 midi_bypass.set (DataType::MIDI, 1);
1295 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1296 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
1297 in.set(DataType::MIDI, 0);
1300 bool no_inputs = true;
1301 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1302 if (inputs.get (*t) != 0) {
1309 /* no inputs so we can take any input configuration since we throw it away */
1310 out = outputs + midi_bypass;
1311 return Match (NoInputs, 1);
1314 /* Plugin inputs match requested inputs exactly */
1316 out = outputs + midi_bypass;
1317 return Match (ExactMatch, 1);
1320 /* We may be able to run more than one copy of the plugin within this insert
1321 to cope with the insert having more inputs than the plugin.
1322 We allow replication only for plugins with either zero or 1 inputs and outputs
1323 for every valid data type.
1327 bool can_replicate = true;
1328 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1330 uint32_t nin = inputs.get (*t);
1332 // No inputs of this type
1333 if (nin == 0 && in.get(*t) == 0) {
1337 if (nin != 1 || outputs.get (*t) != 1) {
1338 can_replicate = false;
1342 // Potential factor not set yet
1344 f = in.get(*t) / nin;
1347 // Factor for this type does not match another type, can not replicate
1348 if (f != (in.get(*t) / nin)) {
1349 can_replicate = false;
1354 if (can_replicate && f > 0) {
1355 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1356 out.set (*t, outputs.get(*t) * f);
1359 return Match (Replicate, f);
1362 /* If the processor has exactly one input of a given type, and
1363 the plugin has more, we can feed the single processor input
1364 to some or all of the plugin inputs. This is rather
1365 special-case-y, but the 1-to-many case is by far the
1366 simplest. How do I split thy 2 processor inputs to 3
1367 plugin inputs? Let me count the ways ...
1370 bool can_split = true;
1371 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1373 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
1374 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1376 if (!can_split_type && !nothing_to_do_for_type) {
1382 out = outputs + midi_bypass;
1383 return Match (Split, 1);
1386 /* If the plugin has more inputs than we want, we can `hide' some of them
1387 by feeding them silence.
1390 bool could_hide = false;
1391 bool cannot_hide = false;
1392 ChanCount hide_channels;
1394 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1395 if (inputs.get(*t) > in.get(*t)) {
1396 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1397 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1399 } else if (inputs.get(*t) < in.get(*t)) {
1400 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1405 if (could_hide && !cannot_hide) {
1406 out = outputs + midi_bypass;
1407 return Match (Hide, 1, false, false, hide_channels);
1410 return Match (Impossible, 0);
1415 PluginInsert::get_state ()
1417 return state (true);
1421 PluginInsert::state (bool full)
1423 XMLNode& node = Processor::state (full);
1425 node.add_property("type", _plugins[0]->state_node_name());
1426 node.add_property("unique-id", _plugins[0]->unique_id());
1427 node.add_property("count", string_compose("%1", _plugins.size()));
1429 /* remember actual i/o configuration (for later placeholder
1430 * in case the plugin goes missing) */
1431 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1432 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1434 /* save custom i/o config */
1435 node.add_property("custom", _custom_cfg ? "yes" : "no");
1436 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1438 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1439 node.add_child_nocopy (* _in_map[pc].state (tmp));
1440 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1441 node.add_child_nocopy (* _out_map[pc].state (tmp));
1444 _plugins[0]->set_insert_id(this->id());
1445 node.add_child_nocopy (_plugins[0]->get_state());
1447 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1448 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1450 node.add_child_nocopy (ac->get_state());
1458 PluginInsert::set_control_ids (const XMLNode& node, int version)
1460 const XMLNodeList& nlist = node.children();
1461 XMLNodeConstIterator iter;
1462 set<Evoral::Parameter>::const_iterator p;
1464 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1465 if ((*iter)->name() == Controllable::xml_node_name) {
1466 const XMLProperty* prop;
1468 uint32_t p = (uint32_t)-1;
1470 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1471 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1473 p = lv2plugin->port_index(prop->value().c_str());
1477 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1478 p = atoi (prop->value());
1481 if (p != (uint32_t)-1) {
1483 /* this may create the new controllable */
1485 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1487 #ifndef NO_PLUGIN_STATE
1491 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1493 ac->set_state (**iter, version);
1502 PluginInsert::set_state(const XMLNode& node, int version)
1504 XMLNodeList nlist = node.children();
1505 XMLNodeIterator niter;
1506 XMLPropertyList plist;
1507 const XMLProperty *prop;
1508 ARDOUR::PluginType type;
1510 if ((prop = node.property ("type")) == 0) {
1511 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1515 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1516 type = ARDOUR::LADSPA;
1517 } else if (prop->value() == X_("lv2")) {
1519 } else if (prop->value() == X_("windows-vst")) {
1520 type = ARDOUR::Windows_VST;
1521 } else if (prop->value() == X_("lxvst")) {
1522 type = ARDOUR::LXVST;
1523 } else if (prop->value() == X_("audiounit")) {
1524 type = ARDOUR::AudioUnit;
1525 } else if (prop->value() == X_("luaproc")) {
1528 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1534 prop = node.property ("unique-id");
1537 #ifdef WINDOWS_VST_SUPPORT
1538 /* older sessions contain VST plugins with only an "id" field.
1541 if (type == ARDOUR::Windows_VST) {
1542 prop = node.property ("id");
1546 #ifdef LXVST_SUPPORT
1547 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1549 if (type == ARDOUR::LXVST) {
1550 prop = node.property ("id");
1556 error << _("Plugin has no unique ID field") << endmsg;
1561 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1563 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1564 * allow to move sessions windows <> linux */
1565 #ifdef LXVST_SUPPORT
1566 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1567 type = ARDOUR::LXVST;
1568 plugin = find_plugin (_session, prop->value(), type);
1572 #ifdef WINDOWS_VST_SUPPORT
1573 if (plugin == 0 && type == ARDOUR::LXVST) {
1574 type = ARDOUR::Windows_VST;
1575 plugin = find_plugin (_session, prop->value(), type);
1580 error << string_compose(
1581 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1582 "Perhaps it was removed or moved since it was last used."),
1588 if (type == ARDOUR::Lua) {
1589 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1590 // we need to load the script to set the name and parameters.
1591 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1593 lp->set_script_from_state (*ls);
1597 // The name of the PluginInsert comes from the plugin, nothing else
1598 _name = plugin->get_info()->name;
1602 // Processor::set_state() will set this, but too late
1603 // for it to be available when setting up plugin
1604 // state. We can't call Processor::set_state() until
1605 // the plugins themselves are created and added.
1609 if (_plugins.empty()) {
1610 /* if we are adding the first plugin, we will need to set
1611 up automatable controls.
1613 add_plugin (plugin);
1614 create_automatable_parameters ();
1615 set_control_ids (node, version);
1618 if ((prop = node.property ("count")) != 0) {
1619 sscanf (prop->value().c_str(), "%u", &count);
1622 if (_plugins.size() != count) {
1623 for (uint32_t n = 1; n < count; ++n) {
1624 add_plugin (plugin_factory (plugin));
1628 Processor::set_state (node, version);
1630 PBD::ID new_id = this->id();
1631 PBD::ID old_id = this->id();
1633 if ((prop = node.property ("id")) != 0) {
1634 old_id = prop->value ();
1637 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1639 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1640 and set all plugins to the same state.
1643 if ((*niter)->name() == plugin->state_node_name()) {
1645 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1646 /* Plugin state can include external files which are named after the ID.
1648 * If regenerate_xml_or_string_ids() is set, the ID will already have
1649 * been changed, so we need to use the old ID from the XML to load the
1650 * state and then update the ID.
1652 * When copying a plugin-state, route_ui takes care of of updating the ID,
1653 * but we need to call set_insert_id() to clear the cached plugin-state
1654 * and force a change.
1656 if (!regenerate_xml_or_string_ids ()) {
1657 (*i)->set_insert_id (new_id);
1659 (*i)->set_insert_id (old_id);
1662 (*i)->set_state (**niter, version);
1664 if (regenerate_xml_or_string_ids ()) {
1665 (*i)->set_insert_id (new_id);
1673 if (version < 3000) {
1675 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1676 this is all handled by Automatable
1679 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1680 if ((*niter)->name() == "Redirect") {
1681 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1682 Processor::set_state (**niter, version);
1687 set_parameter_state_2X (node, version);
1690 if ((prop = node.property (X_("custom"))) != 0) {
1691 _custom_cfg = string_is_affirmative (prop->value());
1694 uint32_t in_maps = 0;
1695 uint32_t out_maps = 0;
1696 XMLNodeList kids = node.children ();
1697 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
1698 if ((*i)->name() == X_("ConfiguredOutput")) {
1699 _custom_out = ChanCount(**i);
1701 if (strncmp ((*i)->name().c_str(), X_("InputMap-"), 9) == 0) {
1702 long pc = atol (&((*i)->name().c_str()[9]));
1703 if (pc >=0 && pc <= get_count()) {
1704 _in_map[pc] = ChanMapping (**i);
1708 if (strncmp ((*i)->name().c_str(), X_("OutputMap-"), 10) == 0) {
1709 long pc = atol (&((*i)->name().c_str()[10]));
1710 if (pc >=0 && pc <= get_count()) {
1711 _out_map[pc] = ChanMapping (**i);
1716 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
1717 _maps_from_state = true;
1720 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1724 (*i)->deactivate ();
1732 PluginInsert::update_id (PBD::ID id)
1735 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1736 (*i)->set_insert_id (id);
1741 PluginInsert::set_state_dir (const std::string& d)
1743 // state() only saves the state of the first plugin
1744 _plugins[0]->set_state_dir (d);
1748 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1750 XMLNodeList nlist = node.children();
1751 XMLNodeIterator niter;
1753 /* look for port automation node */
1755 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1757 if ((*niter)->name() != port_automation_node_name) {
1763 XMLNodeConstIterator iter;
1768 cnodes = (*niter)->children ("port");
1770 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1774 if ((cprop = child->property("number")) != 0) {
1775 port = cprop->value().c_str();
1777 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1781 sscanf (port, "%" PRIu32, &port_id);
1783 if (port_id >= _plugins[0]->parameter_count()) {
1784 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1788 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1789 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1791 if (c && c->alist()) {
1792 if (!child->children().empty()) {
1793 c->alist()->set_state (*child->children().front(), version);
1795 /* In some cases 2.X saves lists with min_yval and max_yval
1796 being FLT_MIN and FLT_MAX respectively. This causes problems
1797 in A3 because these min/max values are used to compute
1798 where GUI control points should be drawn. If we see such
1799 values, `correct' them to the min/max of the appropriate
1803 float min_y = c->alist()->get_min_y ();
1804 float max_y = c->alist()->get_max_y ();
1806 ParameterDescriptor desc;
1807 _plugins.front()->get_parameter_descriptor (port_id, desc);
1809 if (min_y == FLT_MIN) {
1813 if (max_y == FLT_MAX) {
1817 c->alist()->set_yrange (min_y, max_y);
1820 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1832 PluginInsert::describe_parameter (Evoral::Parameter param)
1834 if (param.type() == PluginAutomation) {
1835 return _plugins[0]->describe_parameter (param);
1836 } else if (param.type() == PluginPropertyAutomation) {
1837 boost::shared_ptr<AutomationControl> c(automation_control(param));
1838 if (c && !c->desc().label.empty()) {
1839 return c->desc().label;
1842 return Automatable::describe_parameter(param);
1846 PluginInsert::signal_latency() const
1848 if (_user_latency) {
1849 return _user_latency;
1852 return _plugins[0]->signal_latency ();
1856 PluginInsert::type ()
1858 return plugin()->get_info()->type;
1861 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1862 const Evoral::Parameter& param,
1863 const ParameterDescriptor& desc,
1864 boost::shared_ptr<AutomationList> list)
1865 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1869 alist()->reset_default (desc.normal);
1871 list->set_interpolation(Evoral::ControlList::Discrete);
1876 set_flags(Controllable::Toggle);
1880 /** @param val `user' value */
1882 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1885 _set_value (user_val, group_override);
1889 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1891 /* used only by automation playback */
1892 _set_value (user_val, Controllable::NoGroup);
1896 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1898 /* FIXME: probably should be taking out some lock here.. */
1900 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1901 (*i)->set_parameter (_list->parameter().id(), user_val);
1904 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1906 iasp->set_parameter (_list->parameter().id(), user_val);
1909 AutomationControl::set_value (user_val, group_override);
1913 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1915 AutomationControl::set_value (user_val, Controllable::NoGroup);
1919 PluginInsert::PluginControl::get_state ()
1923 XMLNode& node (AutomationControl::get_state());
1924 ss << parameter().id();
1925 node.add_property (X_("parameter"), ss.str());
1927 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1929 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1936 /** @return `user' val */
1938 PluginInsert::PluginControl::get_value () const
1940 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1946 return plugin->get_parameter (_list->parameter().id());
1949 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1950 const Evoral::Parameter& param,
1951 const ParameterDescriptor& desc,
1952 boost::shared_ptr<AutomationList> list)
1953 : AutomationControl (p->session(), param, desc, list)
1957 alist()->set_yrange (desc.lower, desc.upper);
1958 alist()->reset_default (desc.normal);
1962 set_flags(Controllable::Toggle);
1967 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1970 set_value_unchecked (user_val);
1975 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1977 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1978 This is lossy, but better than nothing until Ardour's automation system
1979 can handle various datatypes all the way down. */
1980 const Variant value(_desc.datatype, user_val);
1981 if (value.type() == Variant::NOTHING) {
1982 error << "set_value(double) called for non-numeric property" << endmsg;
1986 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1987 (*i)->set_property(_list->parameter().id(), value);
1991 AutomationControl::set_value (user_val, Controllable::NoGroup);
1995 PluginInsert::PluginPropertyControl::get_state ()
1999 XMLNode& node (AutomationControl::get_state());
2000 ss << parameter().id();
2001 node.add_property (X_("property"), ss.str());
2002 node.remove_property (X_("value"));
2008 PluginInsert::PluginPropertyControl::get_value () const
2010 return _value.to_double();
2013 boost::shared_ptr<Plugin>
2014 PluginInsert::get_impulse_analysis_plugin()
2016 boost::shared_ptr<Plugin> ret;
2017 if (_impulseAnalysisPlugin.expired()) {
2018 ret = plugin_factory(_plugins[0]);
2019 ret->configure_io (internal_input_streams (), internal_output_streams ());
2020 _impulseAnalysisPlugin = ret;
2022 ret = _impulseAnalysisPlugin.lock();
2029 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2031 // called from outside the audio thread, so this should be safe
2032 // only do audio as analysis is (currently) only for audio plugins
2033 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, internal_input_streams().n_audio(), nframes);
2034 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2036 _signal_analysis_collected_nframes = 0;
2037 _signal_analysis_collect_nframes_max = nframes;
2040 /** Add a plugin to our list */
2042 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2044 plugin->set_insert_id (this->id());
2046 if (_plugins.empty()) {
2047 /* first (and probably only) plugin instance - connect to relevant signals
2050 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2051 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2052 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2055 _plugins.push_back (plugin);
2059 PluginInsert::realtime_handle_transport_stopped ()
2061 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2062 (*i)->realtime_handle_transport_stopped ();
2067 PluginInsert::realtime_locate ()
2069 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2070 (*i)->realtime_locate ();
2075 PluginInsert::monitoring_changed ()
2077 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2078 (*i)->monitoring_changed ();
2083 PluginInsert::start_touch (uint32_t param_id)
2085 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2087 ac->start_touch (session().audible_frame());
2092 PluginInsert::end_touch (uint32_t param_id)
2094 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2096 ac->stop_touch (true, session().audible_frame());
2100 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2103 case PluginInsert::Impossible: o << "Impossible"; break;
2104 case PluginInsert::Delegate: o << "Delegate"; break;
2105 case PluginInsert::NoInputs: o << "NoInputs"; break;
2106 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2107 case PluginInsert::Replicate: o << "Replicate"; break;
2108 case PluginInsert::Split: o << "Split"; break;
2109 case PluginInsert::Hide: o << "Hide"; break;
2111 o << " cnt: " << m.plugins
2112 << (m.strict_io ? " strict-io" : "")
2113 << (m.custom_cfg ? " custom-cfg" : "");
2114 if (m.method == PluginInsert::Hide) {
2115 o << " hide: " << m.hide;