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 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1050 (*i)->set_state (**niter, version);
1057 if (version < 3000) {
1059 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1060 this is all handled by Automatable
1063 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1064 if ((*niter)->name() == "Redirect") {
1065 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1066 Processor::set_state (**niter, version);
1071 set_parameter_state_2X (node, version);
1074 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1078 (*i)->deactivate ();
1086 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1088 XMLNodeList nlist = node.children();
1089 XMLNodeIterator niter;
1091 /* look for port automation node */
1093 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1095 if ((*niter)->name() != port_automation_node_name) {
1101 XMLNodeConstIterator iter;
1106 cnodes = (*niter)->children ("port");
1108 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1112 if ((cprop = child->property("number")) != 0) {
1113 port = cprop->value().c_str();
1115 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1119 sscanf (port, "%" PRIu32, &port_id);
1121 if (port_id >= _plugins[0]->parameter_count()) {
1122 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1126 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1127 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1130 if (!child->children().empty()) {
1131 c->alist()->set_state (*child->children().front(), version);
1133 /* In some cases 2.X saves lists with min_yval and max_yval
1134 being FLT_MIN and FLT_MAX respectively. This causes problems
1135 in A3 because these min/max values are used to compute
1136 where GUI control points should be drawn. If we see such
1137 values, `correct' them to the min/max of the appropriate
1141 float min_y = c->alist()->get_min_y ();
1142 float max_y = c->alist()->get_max_y ();
1144 ParameterDescriptor desc;
1145 _plugins.front()->get_parameter_descriptor (port_id, desc);
1147 if (min_y == FLT_MIN) {
1151 if (max_y == FLT_MAX) {
1155 c->alist()->set_yrange (min_y, max_y);
1158 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1170 PluginInsert::describe_parameter (Evoral::Parameter param)
1172 if (param.type() == PluginAutomation) {
1173 return _plugins[0]->describe_parameter (param);
1174 } else if (param.type() == PluginPropertyAutomation) {
1175 boost::shared_ptr<AutomationControl> c(automation_control(param));
1176 if (c && !c->desc().label.empty()) {
1177 return c->desc().label;
1180 return Automatable::describe_parameter(param);
1184 PluginInsert::signal_latency() const
1186 if (_user_latency) {
1187 return _user_latency;
1190 return _plugins[0]->signal_latency ();
1194 PluginInsert::type ()
1196 return plugin()->get_info()->type;
1199 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1200 const Evoral::Parameter& param,
1201 const ParameterDescriptor& desc,
1202 boost::shared_ptr<AutomationList> list)
1203 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1207 alist()->reset_default (desc.normal);
1209 list->set_interpolation(Evoral::ControlList::Discrete);
1214 set_flags(Controllable::Toggle);
1218 /** @param val `user' value */
1220 PluginInsert::PluginControl::set_value (double user_val)
1222 /* FIXME: probably should be taking out some lock here.. */
1224 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1225 (*i)->set_parameter (_list->parameter().id(), user_val);
1228 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1230 iasp->set_parameter (_list->parameter().id(), user_val);
1233 AutomationControl::set_value (user_val);
1237 PluginInsert::PluginControl::internal_to_interface (double val) const
1239 val = Controllable::internal_to_interface(val);
1241 if (_desc.logarithmic) {
1243 val = pow (val, 1/1.5);
1253 PluginInsert::PluginControl::interface_to_internal (double val) const
1255 if (_desc.logarithmic) {
1259 val = pow (val, 1.5);
1263 val = Controllable::interface_to_internal(val);
1269 PluginInsert::PluginControl::get_state ()
1273 XMLNode& node (AutomationControl::get_state());
1274 ss << parameter().id();
1275 node.add_property (X_("parameter"), ss.str());
1280 /** @return `user' val */
1282 PluginInsert::PluginControl::get_value () const
1284 /* FIXME: probably should be taking out some lock here.. */
1285 return _plugin->get_parameter (_list->parameter());
1288 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1289 const Evoral::Parameter& param,
1290 const ParameterDescriptor& desc,
1291 boost::shared_ptr<AutomationList> list)
1292 : AutomationControl (p->session(), param, desc, list)
1296 alist()->set_yrange (desc.lower, desc.upper);
1297 alist()->reset_default (desc.normal);
1301 set_flags(Controllable::Toggle);
1306 PluginInsert::PluginPropertyControl::set_value (double user_val)
1308 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1309 This is lossy, but better than nothing until Ardour's automation system
1310 can handle various datatypes all the way down. */
1311 const Variant value(_desc.datatype, user_val);
1312 if (value.type() == Variant::NOTHING) {
1313 error << "set_value(double) called for non-numeric property" << endmsg;
1317 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1318 (*i)->set_property(_list->parameter().id(), value);
1322 AutomationControl::set_value(user_val);
1326 PluginInsert::PluginPropertyControl::get_state ()
1330 XMLNode& node (AutomationControl::get_state());
1331 ss << parameter().id();
1332 node.add_property (X_("property"), ss.str());
1333 node.remove_property (X_("value"));
1339 PluginInsert::PluginPropertyControl::get_value () const
1341 return _value.to_double();
1344 boost::shared_ptr<Plugin>
1345 PluginInsert::get_impulse_analysis_plugin()
1347 boost::shared_ptr<Plugin> ret;
1348 if (_impulseAnalysisPlugin.expired()) {
1349 ret = plugin_factory(_plugins[0]);
1350 _impulseAnalysisPlugin = ret;
1352 ret = _impulseAnalysisPlugin.lock();
1359 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1361 // called from outside the audio thread, so this should be safe
1362 // only do audio as analysis is (currently) only for audio plugins
1363 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1364 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1366 _signal_analysis_collected_nframes = 0;
1367 _signal_analysis_collect_nframes_max = nframes;
1370 /** Add a plugin to our list */
1372 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1374 plugin->set_insert_id (this->id());
1376 if (_plugins.empty()) {
1377 /* first (and probably only) plugin instance - connect to relevant signals
1380 plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
1381 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1382 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1385 _plugins.push_back (plugin);
1389 PluginInsert::realtime_handle_transport_stopped ()
1391 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1392 (*i)->realtime_handle_transport_stopped ();
1397 PluginInsert::realtime_locate ()
1399 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1400 (*i)->realtime_locate ();
1405 PluginInsert::monitoring_changed ()
1407 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1408 (*i)->monitoring_changed ();
1413 PluginInsert::start_touch (uint32_t param_id)
1415 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1417 ac->start_touch (session().audible_frame());
1422 PluginInsert::end_touch (uint32_t param_id)
1424 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1426 ac->stop_touch (true, session().audible_frame());