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/plugin.h"
37 #include "ardour/plugin_insert.h"
40 #include "ardour/lv2_plugin.h"
43 #ifdef WINDOWS_VST_SUPPORT
44 #include "ardour/windows_vst_plugin.h"
48 #include "ardour/lxvst_plugin.h"
51 #ifdef AUDIOUNIT_SUPPORT
52 #include "ardour/audio_unit.h"
55 #include "ardour/session.h"
56 #include "ardour/types.h"
61 using namespace ARDOUR;
64 const string PluginInsert::port_automation_node_name = "PortAutomation";
66 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
67 : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
68 , _signal_analysis_collected_nframes(0)
69 , _signal_analysis_collect_nframes_max(0)
71 /* the first is the master */
75 create_automatable_parameters ();
80 PluginInsert::set_count (uint32_t num)
82 bool require_state = !_plugins.empty();
84 /* this is a bad idea.... we shouldn't do this while active.
85 only a route holding their redirect_lock should be calling this
90 } else if (num > _plugins.size()) {
91 uint32_t diff = num - _plugins.size();
93 for (uint32_t n = 0; n < diff; ++n) {
94 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
101 /* XXX do something */
105 } else if (num < _plugins.size()) {
106 uint32_t diff = _plugins.size() - num;
107 for (uint32_t n= 0; n < diff; ++n) {
115 PluginInsert::~PluginInsert ()
120 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
122 if (which.type() != PluginAutomation)
125 boost::shared_ptr<AutomationControl> c
126 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
129 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
134 PluginInsert::output_streams() const
136 assert (!_plugins.empty());
138 PluginInfoPtr info = _plugins.front()->get_info();
140 if (info->reconfigurable_io()) {
141 ChanCount out = _plugins.front()->output_streams ();
142 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
145 ChanCount out = info->n_outputs;
146 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
147 out.set_audio (out.n_audio() * _plugins.size());
148 out.set_midi (out.n_midi() * _plugins.size() + midi_bypass.n_midi());
154 PluginInsert::input_streams() const
156 assert (!_plugins.empty());
160 PluginInfoPtr info = _plugins.front()->get_info();
162 if (info->reconfigurable_io()) {
163 assert (_plugins.size() == 1);
164 in = _plugins.front()->input_streams();
169 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
171 if (_match.method == Split) {
173 /* we are splitting 1 processor input to multiple plugin inputs,
174 so we have a maximum of 1 stream of each type.
176 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
177 if (in.get (*t) > 1) {
183 } else if (_match.method == Hide) {
185 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
186 in.set (*t, in.get (*t) - _match.hide.get (*t));
192 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
193 in.set (*t, in.get (*t) * _plugins.size ());
201 PluginInsert::natural_output_streams() const
203 return _plugins[0]->get_info()->n_outputs;
207 PluginInsert::natural_input_streams() const
209 return _plugins[0]->get_info()->n_inputs;
213 PluginInsert::has_no_inputs() const
215 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
219 PluginInsert::has_no_audio_inputs() const
221 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
225 PluginInsert::is_midi_instrument() const
227 /* XXX more finesse is possible here. VST plugins have a
228 a specific "instrument" flag, for example.
230 PluginInfoPtr pi = _plugins[0]->get_info();
232 return pi->n_inputs.n_midi() != 0 &&
233 pi->n_outputs.n_audio() > 0;
237 PluginInsert::create_automatable_parameters ()
239 assert (!_plugins.empty());
241 set<Evoral::Parameter> a = _plugins.front()->automatable ();
243 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
244 if (i->type() == PluginAutomation) {
246 Evoral::Parameter param(*i);
248 ParameterDescriptor desc;
249 _plugins.front()->get_parameter_descriptor(i->id(), desc);
251 can_automate (param);
252 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
253 add_control (boost::shared_ptr<AutomationControl> (new PluginControl(this, param, desc, list)));
254 } else if (i->type() == PluginPropertyAutomation) {
255 Evoral::Parameter param(*i);
256 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
257 if (desc.datatype != Variant::NOTHING) {
258 boost::shared_ptr<AutomationList> list;
259 if (Variant::type_is_numeric(desc.datatype)) {
260 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
262 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
269 PluginInsert::parameter_changed (uint32_t which, float val)
271 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
276 Plugins::iterator i = _plugins.begin();
278 /* don't set the first plugin, just all the slaves */
280 if (i != _plugins.end()) {
282 for (; i != _plugins.end(); ++i) {
283 (*i)->set_parameter (which, val);
290 PluginInsert::set_block_size (pframes_t nframes)
293 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
294 if ((*i)->set_block_size (nframes) != 0) {
302 PluginInsert::activate ()
304 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
308 Processor::activate ();
312 PluginInsert::deactivate ()
314 Processor::deactivate ();
316 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
322 PluginInsert::flush ()
324 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
330 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
332 // Calculate if, and how many frames we need to collect for analysis
333 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
334 _signal_analysis_collected_nframes);
335 if (nframes < collect_signal_nframes) { // we might not get all frames now
336 collect_signal_nframes = nframes;
339 ChanCount const in_streams = input_streams ();
340 ChanCount const out_streams = output_streams ();
342 ChanMapping in_map (in_streams);
343 ChanMapping out_map (out_streams);
345 if (_match.method == Split) {
346 /* fix the input mapping so that we have maps for each of the plugin's inputs */
347 in_map = ChanMapping (natural_input_streams ());
349 /* copy the first stream's buffer contents to the others */
350 /* XXX: audio only */
351 uint32_t first_idx = in_map.get (DataType::AUDIO, 0, &valid);
353 for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
354 bufs.get_audio(in_map.get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
359 bufs.set_count(ChanCount::max(bufs.count(), in_streams));
360 bufs.set_count(ChanCount::max(bufs.count(), out_streams));
362 /* Note that we've already required that plugins
363 be able to handle in-place processing.
370 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
372 boost::shared_ptr<AutomationControl> c
373 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
375 if (c->list() && c->automation_playback()) {
378 const float val = c->list()->rt_safe_eval (now, valid);
388 if (collect_signal_nframes > 0) {
390 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
391 //std::cerr << " streams " << input_streams().n_audio() << std::endl;
392 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
394 _signal_analysis_inputs.set_count(input_streams());
396 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
397 _signal_analysis_inputs.get_audio(i).read_from(
399 collect_signal_nframes,
400 _signal_analysis_collected_nframes); // offset is for target buffer
405 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
406 (*i)->connect_and_run(bufs, in_map, out_map, nframes, offset);
407 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
408 in_map.offset_to(*t, natural_input_streams().get(*t));
409 out_map.offset_to(*t, natural_output_streams().get(*t));
413 if (collect_signal_nframes > 0) {
415 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
416 //std::cerr << " streams " << output_streams().n_audio() << std::endl;
418 _signal_analysis_outputs.set_count(output_streams());
420 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
421 _signal_analysis_outputs.get_audio(i).read_from(
423 collect_signal_nframes,
424 _signal_analysis_collected_nframes); // offset is for target buffer
427 _signal_analysis_collected_nframes += collect_signal_nframes;
428 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
430 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
431 _signal_analysis_collect_nframes_max = 0;
432 _signal_analysis_collected_nframes = 0;
434 AnalysisDataGathered(&_signal_analysis_inputs,
435 &_signal_analysis_outputs);
438 /* leave remaining channel buffers alone */
442 PluginInsert::silence (framecnt_t nframes)
448 ChanMapping in_map(input_streams());
449 ChanMapping out_map(output_streams());
451 if (_match.method == Split) {
452 /* fix the input mapping so that we have maps for each of the plugin's inputs */
453 in_map = ChanMapping (natural_input_streams ());
456 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
457 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
462 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
464 if (_pending_active) {
465 /* run as normal if we are active or moving from inactive to active */
467 if (_session.transport_rolling() || _session.bounce_processing()) {
468 automation_run (bufs, start_frame, nframes);
470 connect_and_run (bufs, nframes, 0, false);
474 uint32_t in = input_streams ().n_audio ();
475 uint32_t out = output_streams().n_audio ();
477 if (has_no_audio_inputs() || in == 0) {
479 /* silence all (audio) outputs. Should really declick
480 * at the transitions of "active"
483 for (uint32_t n = 0; n < out; ++n) {
484 bufs.get_audio (n).silence (nframes);
487 } else if (out > in) {
489 /* not active, but something has make up for any channel count increase */
491 // TODO: option round-robin (n % in) or silence additional buffers ??
492 // for now , simply replicate last buffer
493 for (uint32_t n = in; n < out; ++n) {
494 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
498 bufs.count().set_audio (out);
501 _active = _pending_active;
503 /* we have no idea whether the plugin generated silence or not, so mark
504 * all buffers appropriately.
510 PluginInsert::set_parameter (Evoral::Parameter param, float val)
512 if (param.type() != PluginAutomation) {
516 /* the others will be set from the event triggered by this */
518 _plugins[0]->set_parameter (param.id(), val);
520 boost::shared_ptr<AutomationControl> ac
521 = boost::dynamic_pointer_cast<AutomationControl>(control(param));
526 warning << "set_parameter called for nonexistant parameter "
527 << EventTypeMap::instance().to_symbol(param) << endmsg;
530 _session.set_dirty();
534 PluginInsert::get_parameter (Evoral::Parameter param)
536 if (param.type() != PluginAutomation) {
539 assert (!_plugins.empty ());
540 return _plugins[0]->get_parameter (param.id());
545 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
547 Evoral::ControlEvent next_event (0, 0.0f);
548 framepos_t now = start;
549 framepos_t end = now + nframes;
550 framecnt_t offset = 0;
552 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
555 connect_and_run (bufs, nframes, offset, false);
559 if (!find_next_event (now, end, next_event) || requires_fixed_sized_buffers()) {
561 /* no events have a time within the relevant range */
563 connect_and_run (bufs, nframes, offset, true, now);
569 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
571 connect_and_run (bufs, cnt, offset, true, now);
577 if (!find_next_event (now, end, next_event)) {
582 /* cleanup anything that is left to do */
585 connect_and_run (bufs, nframes, offset, true, now);
590 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
592 if (param.type() != PluginAutomation)
595 if (_plugins.empty()) {
596 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
598 abort(); /*NOTREACHED*/
601 return _plugins[0]->default_value (param.id());
604 boost::shared_ptr<Plugin>
605 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
607 boost::shared_ptr<LadspaPlugin> lp;
609 boost::shared_ptr<LV2Plugin> lv2p;
611 #ifdef WINDOWS_VST_SUPPORT
612 boost::shared_ptr<WindowsVSTPlugin> vp;
615 boost::shared_ptr<LXVSTPlugin> lxvp;
617 #ifdef AUDIOUNIT_SUPPORT
618 boost::shared_ptr<AUPlugin> ap;
621 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
622 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
624 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
625 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
627 #ifdef WINDOWS_VST_SUPPORT
628 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
629 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
632 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
633 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
635 #ifdef AUDIOUNIT_SUPPORT
636 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
637 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
641 fatal << string_compose (_("programming error: %1"),
642 X_("unknown plugin type in PluginInsert::plugin_factory"))
644 abort(); /*NOTREACHED*/
645 return boost::shared_ptr<Plugin> ((Plugin*) 0);
649 PluginInsert::configure_io (ChanCount in, ChanCount out)
651 Match old_match = _match;
652 ChanCount old_in = input_streams ();
653 ChanCount old_out = output_streams ();
655 /* set the matching method and number of plugins that we will use to meet this configuration */
656 _match = private_can_support_io_configuration (in, out);
657 if (set_count (_match.plugins) == false) {
661 if ( (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
666 PluginIoReConfigure (); /* EMIT SIGNAL */
669 /* configure plugins */
670 switch (_match.method) {
673 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out)) {
679 if (_plugins.front()->configure_io (in, out) == false) {
685 // we don't know the analysis window size, so we must work with the
686 // current buffer size here. each request for data fills in these
687 // buffers and the analyser makes sure it gets enough data for the
689 session().ensure_buffer_set (_signal_analysis_inputs, in);
690 //_signal_analysis_inputs.set_count (in);
692 session().ensure_buffer_set (_signal_analysis_outputs, out);
693 //_signal_analysis_outputs.set_count (out);
695 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
697 return Processor::configure_io (in, out);
700 /** Decide whether this PluginInsert can support a given IO configuration.
701 * To do this, we run through a set of possible solutions in rough order of
704 * @param in Required input channel count.
705 * @param out Filled in with the output channel count if we return true.
706 * @return true if the given IO configuration can be supported.
709 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
711 return private_can_support_io_configuration (in, out).method != Impossible;
714 /** A private version of can_support_io_configuration which returns the method
715 * by which the configuration can be matched, rather than just whether or not
719 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
721 if (_plugins.empty()) {
725 PluginInfoPtr info = _plugins.front()->get_info();
726 ChanCount in; in += inx;
729 if (info->reconfigurable_io()) {
730 /* Plugin has flexible I/O, so delegate to it */
731 bool const r = _plugins.front()->can_support_io_configuration (in, out);
733 return Match (Impossible, 0);
736 return Match (Delegate, 1);
739 ChanCount inputs = info->n_inputs;
740 ChanCount outputs = info->n_outputs;
742 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
743 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
744 midi_bypass.set(DataType::MIDI, 1);
746 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
747 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
748 in.set(DataType::MIDI, 0);
751 bool no_inputs = true;
752 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
753 if (inputs.get (*t) != 0) {
760 /* no inputs so we can take any input configuration since we throw it away */
761 out = outputs + midi_bypass;
762 return Match (NoInputs, 1);
765 /* Plugin inputs match requested inputs exactly */
767 out = outputs + midi_bypass;
768 return Match (ExactMatch, 1);
771 /* We may be able to run more than one copy of the plugin within this insert
772 to cope with the insert having more inputs than the plugin.
773 We allow replication only for plugins with either zero or 1 inputs and outputs
774 for every valid data type.
778 bool can_replicate = true;
779 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
781 uint32_t nin = inputs.get (*t);
783 // No inputs of this type
784 if (nin == 0 && in.get(*t) == 0) {
788 if (nin != 1 || outputs.get (*t) != 1) {
789 can_replicate = false;
793 // Potential factor not set yet
795 f = in.get(*t) / nin;
798 // Factor for this type does not match another type, can not replicate
799 if (f != (in.get(*t) / nin)) {
800 can_replicate = false;
806 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
807 out.set (*t, outputs.get(*t) * f);
810 return Match (Replicate, f);
813 /* If the processor has exactly one input of a given type, and
814 the plugin has more, we can feed the single processor input
815 to some or all of the plugin inputs. This is rather
816 special-case-y, but the 1-to-many case is by far the
817 simplest. How do I split thy 2 processor inputs to 3
818 plugin inputs? Let me count the ways ...
821 bool can_split = true;
822 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
824 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
825 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
827 if (!can_split_type && !nothing_to_do_for_type) {
833 out = outputs + midi_bypass;
834 return Match (Split, 1);
837 /* If the plugin has more inputs than we want, we can `hide' some of them
838 by feeding them silence.
841 bool could_hide = false;
842 bool cannot_hide = false;
843 ChanCount hide_channels;
845 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
846 if (inputs.get(*t) > in.get(*t)) {
847 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
848 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
850 } else if (inputs.get(*t) < in.get(*t)) {
851 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
856 if (could_hide && !cannot_hide) {
857 out = outputs + midi_bypass;
858 return Match (Hide, 1, hide_channels);
862 return Match (Impossible, 0);
866 PluginInsert::get_state ()
872 PluginInsert::state (bool full)
874 XMLNode& node = Processor::state (full);
876 node.add_property("type", _plugins[0]->state_node_name());
877 node.add_property("unique-id", _plugins[0]->unique_id());
878 node.add_property("count", string_compose("%1", _plugins.size()));
879 node.add_child_nocopy (_plugins[0]->get_state());
881 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
882 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
884 node.add_child_nocopy (ac->get_state());
892 PluginInsert::set_control_ids (const XMLNode& node, int version)
894 const XMLNodeList& nlist = node.children();
895 XMLNodeConstIterator iter;
896 set<Evoral::Parameter>::const_iterator p;
898 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
899 if ((*iter)->name() == Controllable::xml_node_name) {
900 const XMLProperty* prop;
902 if ((prop = (*iter)->property (X_("parameter"))) != 0) {
903 uint32_t p = atoi (prop->value());
905 /* this may create the new controllable */
907 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
909 #ifndef NO_PLUGIN_STATE
913 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
915 ac->set_state (**iter, version);
924 PluginInsert::set_state(const XMLNode& node, int version)
926 XMLNodeList nlist = node.children();
927 XMLNodeIterator niter;
928 XMLPropertyList plist;
929 const XMLProperty *prop;
930 ARDOUR::PluginType type;
932 if ((prop = node.property ("type")) == 0) {
933 error << _("XML node describing plugin is missing the `type' field") << endmsg;
937 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
938 type = ARDOUR::LADSPA;
939 } else if (prop->value() == X_("lv2")) {
941 } else if (prop->value() == X_("windows-vst")) {
942 type = ARDOUR::Windows_VST;
943 } else if (prop->value() == X_("lxvst")) {
944 type = ARDOUR::LXVST;
945 } else if (prop->value() == X_("audiounit")) {
946 type = ARDOUR::AudioUnit;
948 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
954 prop = node.property ("unique-id");
957 #ifdef WINDOWS_VST_SUPPORT
958 /* older sessions contain VST plugins with only an "id" field.
961 if (type == ARDOUR::Windows_VST) {
962 prop = node.property ("id");
967 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
969 if (type == ARDOUR::LXVST) {
970 prop = node.property ("id");
976 error << _("Plugin has no unique ID field") << endmsg;
981 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
983 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
984 * allow to move sessions windows <> linux */
986 if (plugin == 0 && type == ARDOUR::Windows_VST) {
987 type = ARDOUR::LXVST;
988 plugin = find_plugin (_session, prop->value(), type);
992 #ifdef WINDOWS_VST_SUPPORT
993 if (plugin == 0 && type == ARDOUR::LXVST) {
994 type = ARDOUR::Windows_VST;
995 plugin = find_plugin (_session, prop->value(), type);
1000 error << string_compose(
1001 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1002 "Perhaps it was removed or moved since it was last used."),
1008 // The name of the PluginInsert comes from the plugin, nothing else
1009 _name = plugin->get_info()->name;
1013 // Processor::set_state() will set this, but too late
1014 // for it to be available when setting up plugin
1015 // state. We can't call Processor::set_state() until
1016 // the plugins themselves are created and added.
1020 if (_plugins.empty()) {
1021 /* if we are adding the first plugin, we will need to set
1022 up automatable controls.
1024 add_plugin (plugin);
1025 create_automatable_parameters ();
1026 set_control_ids (node, version);
1029 if ((prop = node.property ("count")) != 0) {
1030 sscanf (prop->value().c_str(), "%u", &count);
1033 if (_plugins.size() != count) {
1034 for (uint32_t n = 1; n < count; ++n) {
1035 add_plugin (plugin_factory (plugin));
1039 Processor::set_state (node, version);
1041 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1043 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1044 and set all plugins to the same state.
1047 if ((*niter)->name() == plugin->state_node_name()) {
1049 plugin->set_state (**niter, version);
1051 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1052 (*i)->set_state (**niter, version);
1059 if (version < 3000) {
1061 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1062 this is all handled by Automatable
1065 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1066 if ((*niter)->name() == "Redirect") {
1067 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1068 Processor::set_state (**niter, version);
1073 set_parameter_state_2X (node, version);
1076 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1080 (*i)->deactivate ();
1088 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1090 XMLNodeList nlist = node.children();
1091 XMLNodeIterator niter;
1093 /* look for port automation node */
1095 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1097 if ((*niter)->name() != port_automation_node_name) {
1103 XMLNodeConstIterator iter;
1108 cnodes = (*niter)->children ("port");
1110 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1114 if ((cprop = child->property("number")) != 0) {
1115 port = cprop->value().c_str();
1117 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1121 sscanf (port, "%" PRIu32, &port_id);
1123 if (port_id >= _plugins[0]->parameter_count()) {
1124 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1128 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1129 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1132 if (!child->children().empty()) {
1133 c->alist()->set_state (*child->children().front(), version);
1135 /* In some cases 2.X saves lists with min_yval and max_yval
1136 being FLT_MIN and FLT_MAX respectively. This causes problems
1137 in A3 because these min/max values are used to compute
1138 where GUI control points should be drawn. If we see such
1139 values, `correct' them to the min/max of the appropriate
1143 float min_y = c->alist()->get_min_y ();
1144 float max_y = c->alist()->get_max_y ();
1146 ParameterDescriptor desc;
1147 _plugins.front()->get_parameter_descriptor (port_id, desc);
1149 if (min_y == FLT_MIN) {
1153 if (max_y == FLT_MAX) {
1157 c->alist()->set_yrange (min_y, max_y);
1160 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1172 PluginInsert::describe_parameter (Evoral::Parameter param)
1174 if (param.type() == PluginAutomation) {
1175 return _plugins[0]->describe_parameter (param);
1176 } else if (param.type() == PluginPropertyAutomation) {
1177 boost::shared_ptr<AutomationControl> c(automation_control(param));
1178 if (c && !c->desc().label.empty()) {
1179 return c->desc().label;
1182 return Automatable::describe_parameter(param);
1186 PluginInsert::signal_latency() const
1188 if (_user_latency) {
1189 return _user_latency;
1192 return _plugins[0]->signal_latency ();
1196 PluginInsert::type ()
1198 return plugin()->get_info()->type;
1201 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1202 const Evoral::Parameter& param,
1203 const ParameterDescriptor& desc,
1204 boost::shared_ptr<AutomationList> list)
1205 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1209 alist()->reset_default (desc.normal);
1211 list->set_interpolation(Evoral::ControlList::Discrete);
1216 set_flags(Controllable::Toggle);
1220 /** @param val `user' value */
1222 PluginInsert::PluginControl::set_value (double user_val)
1224 /* FIXME: probably should be taking out some lock here.. */
1226 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1227 (*i)->set_parameter (_list->parameter().id(), user_val);
1230 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1232 iasp->set_parameter (_list->parameter().id(), user_val);
1235 AutomationControl::set_value (user_val);
1239 PluginInsert::PluginControl::internal_to_interface (double val) const
1241 val = Controllable::internal_to_interface(val);
1243 if (_desc.logarithmic) {
1245 val = pow (val, 1/1.5);
1255 PluginInsert::PluginControl::interface_to_internal (double val) const
1257 if (_desc.logarithmic) {
1261 val = pow (val, 1.5);
1265 val = Controllable::interface_to_internal(val);
1271 PluginInsert::PluginControl::get_state ()
1275 XMLNode& node (AutomationControl::get_state());
1276 ss << parameter().id();
1277 node.add_property (X_("parameter"), ss.str());
1282 /** @return `user' val */
1284 PluginInsert::PluginControl::get_value () const
1286 /* FIXME: probably should be taking out some lock here.. */
1287 return _plugin->get_parameter (_list->parameter());
1290 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1291 const Evoral::Parameter& param,
1292 const ParameterDescriptor& desc,
1293 boost::shared_ptr<AutomationList> list)
1294 : AutomationControl (p->session(), param, desc, list)
1298 alist()->set_yrange (desc.lower, desc.upper);
1299 alist()->reset_default (desc.normal);
1303 set_flags(Controllable::Toggle);
1308 PluginInsert::PluginPropertyControl::set_value (double user_val)
1310 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1311 This is lossy, but better than nothing until Ardour's automation system
1312 can handle various datatypes all the way down. */
1313 const Variant value(_desc.datatype, user_val);
1314 if (value.type() == Variant::NOTHING) {
1315 error << "set_value(double) called for non-numeric property" << endmsg;
1319 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1320 (*i)->set_property(_list->parameter().id(), value);
1324 AutomationControl::set_value(user_val);
1328 PluginInsert::PluginPropertyControl::get_state ()
1332 XMLNode& node (AutomationControl::get_state());
1333 ss << parameter().id();
1334 node.add_property (X_("property"), ss.str());
1335 node.remove_property (X_("value"));
1341 PluginInsert::PluginPropertyControl::get_value () const
1343 return _value.to_double();
1346 boost::shared_ptr<Plugin>
1347 PluginInsert::get_impulse_analysis_plugin()
1349 boost::shared_ptr<Plugin> ret;
1350 if (_impulseAnalysisPlugin.expired()) {
1351 ret = plugin_factory(_plugins[0]);
1352 _impulseAnalysisPlugin = ret;
1354 ret = _impulseAnalysisPlugin.lock();
1361 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1363 // called from outside the audio thread, so this should be safe
1364 // only do audio as analysis is (currently) only for audio plugins
1365 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1366 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1368 _signal_analysis_collected_nframes = 0;
1369 _signal_analysis_collect_nframes_max = nframes;
1372 /** Add a plugin to our list */
1374 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1376 plugin->set_insert_id (this->id());
1378 if (_plugins.empty()) {
1379 /* first (and probably only) plugin instance - connect to relevant signals
1382 plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
1383 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1384 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1387 _plugins.push_back (plugin);
1391 PluginInsert::realtime_handle_transport_stopped ()
1393 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1394 (*i)->realtime_handle_transport_stopped ();
1399 PluginInsert::realtime_locate ()
1401 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1402 (*i)->realtime_locate ();
1407 PluginInsert::monitoring_changed ()
1409 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1410 (*i)->monitoring_changed ();
1415 PluginInsert::start_touch (uint32_t param_id)
1417 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1419 ac->start_touch (session().audible_frame());
1424 PluginInsert::end_touch (uint32_t param_id)
1426 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1428 ac->stop_touch (true, session().audible_frame());