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.
23 #include <sigc++/bind.h>
25 #include <pbd/failed_constructor.h>
26 #include <pbd/xml++.h>
28 #include <ardour/insert.h>
29 #include <ardour/plugin.h>
30 #include <ardour/port.h>
31 #include <ardour/route.h>
32 #include <ardour/ladspa_plugin.h>
33 #include <ardour/buffer_set.h>
36 #include <ardour/vst_plugin.h>
39 #ifdef HAVE_AUDIOUNITS
40 #include <ardour/audio_unit.h>
43 #include <ardour/audioengine.h>
44 #include <ardour/session.h>
45 #include <ardour/types.h>
50 using namespace ARDOUR;
53 /* ********** FIXME: TYPE ************** */
54 /* Inserts are still definitely audio only */
56 Insert::Insert(Session& s, Placement p)
57 : Redirect (s, s.next_insert_name(), p)
61 Insert::Insert(Session& s, Placement p, int imin, int imax, int omin, int omax)
62 : Redirect (s, s.next_insert_name(), p, imin, imax, omin, omax)
66 Insert::Insert(Session& s, string name, Placement p)
67 : Redirect (s, name, p)
71 /***************************************************************
72 Plugin inserts: send data through a plugin
73 ***************************************************************/
75 const string PluginInsert::port_automation_node_name = "PortAutomation";
77 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug, Placement placement)
78 : Insert (s, plug->name(), placement)
80 /* the first is the master */
82 _plugins.push_back (plug);
84 _plugins[0]->ParameterChanged.connect (mem_fun (*this, &PluginInsert::parameter_changed));
88 save_state (_("initial state"));
91 Glib::Mutex::Lock em (_session.engine().process_lock());
92 IO::MoreChannels (max(input_streams(), output_streams()));
95 RedirectCreated (this); /* EMIT SIGNAL */
98 PluginInsert::PluginInsert (Session& s, const XMLNode& node)
99 : Insert (s, "will change", PreFader)
101 if (set_state (node)) {
102 throw failed_constructor();
107 save_state (_("initial state"));
109 _plugins[0]->ParameterChanged.connect (mem_fun (*this, &PluginInsert::parameter_changed));
112 Glib::Mutex::Lock em (_session.engine().process_lock());
113 IO::MoreChannels (max(input_streams(), output_streams()));
117 PluginInsert::PluginInsert (const PluginInsert& other)
118 : Insert (other._session, other.plugin()->name(), other.placement())
120 uint32_t count = other._plugins.size();
122 /* make as many copies as requested */
123 for (uint32_t n = 0; n < count; ++n) {
124 _plugins.push_back (plugin_factory (other.plugin (n)));
128 _plugins[0]->ParameterChanged.connect (mem_fun (*this, &PluginInsert::parameter_changed));
132 save_state (_("initial state"));
134 RedirectCreated (this); /* EMIT SIGNAL */
138 PluginInsert::set_count (uint32_t num)
140 bool require_state = !_plugins.empty();
142 /* this is a bad idea.... we shouldn't do this while active.
143 only a route holding their redirect_lock should be calling this
148 } else if (num > _plugins.size()) {
149 uint32_t diff = num - _plugins.size();
151 for (uint32_t n = 0; n < diff; ++n) {
152 _plugins.push_back (plugin_factory (_plugins[0]));
155 /* XXX do something */
159 } else if (num < _plugins.size()) {
160 uint32_t diff = _plugins.size() - num;
161 for (uint32_t n= 0; n < diff; ++n) {
170 PluginInsert::init ()
174 set<uint32_t>::iterator s;
177 PluginInsert::~PluginInsert ()
179 GoingAway (); /* EMIT SIGNAL */
183 PluginInsert::automation_list_creation_callback (uint32_t which, AutomationList& alist)
185 alist.automation_state_changed.connect (sigc::bind (mem_fun (*this, &PluginInsert::auto_state_changed), (which)));
189 PluginInsert::auto_state_changed (uint32_t which)
191 AutomationList& alist (automation_list (which));
193 if (alist.automation_state() != Off) {
194 _plugins[0]->set_parameter (which, alist.eval (_session.transport_frame()));
199 PluginInsert::output_streams() const
202 return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_outputs * _plugins.size());
206 PluginInsert::input_streams() const
209 return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_inputs * _plugins.size());
213 PluginInsert::natural_output_streams() const
216 return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_outputs);
220 PluginInsert::natural_input_streams() const
223 return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_inputs);
227 PluginInsert::is_generator() const
229 /* XXX more finesse is possible here. VST plugins have a
230 a specific "instrument" flag, for example.
233 return _plugins[0]->get_info()->n_inputs == 0;
237 PluginInsert::set_automatable ()
241 a = _plugins.front()->automatable ();
243 for (set<uint32_t>::iterator i = a.begin(); i != a.end(); ++i) {
249 PluginInsert::parameter_changed (uint32_t which, float val)
251 vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin();
253 /* don't set the first plugin, just all the slaves */
255 if (i != _plugins.end()) {
257 for (; i != _plugins.end(); ++i) {
258 (*i)->set_parameter (which, val);
264 PluginInsert::set_block_size (jack_nframes_t nframes)
266 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
267 (*i)->set_block_size (nframes);
272 PluginInsert::activate ()
274 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
280 PluginInsert::deactivate ()
282 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
288 PluginInsert::connect_and_run (BufferSet& bufs, jack_nframes_t nframes, jack_nframes_t offset, bool with_auto, jack_nframes_t now)
290 uint32_t in_index = 0;
291 uint32_t out_index = 0;
293 /* Note that we've already required that plugins
294 be able to handle in-place processing.
299 map<uint32_t,AutomationList*>::iterator li;
302 for (n = 0, li = parameter_automation.begin(); li != parameter_automation.end(); ++li, ++n) {
304 AutomationList& alist (*((*li).second));
306 if (alist.automation_playback()) {
309 float val = alist.rt_safe_eval (now, valid);
312 /* set the first plugin, the others will be set via signals */
313 _plugins[0]->set_parameter ((*li).first, val);
320 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
321 (*i)->connect_and_run (bufs, in_index, out_index, nframes, offset);
324 /* leave remaining channel buffers alone */
328 PluginInsert::automation_snapshot (jack_nframes_t now)
330 map<uint32_t,AutomationList*>::iterator li;
332 for (li = parameter_automation.begin(); li != parameter_automation.end(); ++li) {
334 AutomationList *alist = ((*li).second);
335 if (alist != 0 && alist->automation_write ()) {
337 float val = _plugins[0]->get_parameter ((*li).first);
338 alist->rt_add (now, val);
339 last_automation_snapshot = now;
345 PluginInsert::transport_stopped (jack_nframes_t now)
347 map<uint32_t,AutomationList*>::iterator li;
349 for (li = parameter_automation.begin(); li != parameter_automation.end(); ++li) {
350 AutomationList& alist (*(li->second));
351 alist.reposition_for_rt_add (now);
353 if (alist.automation_state() != Off) {
354 _plugins[0]->set_parameter (li->first, alist.eval (now));
360 PluginInsert::silence (jack_nframes_t nframes, jack_nframes_t offset)
362 uint32_t in_index = 0;
363 uint32_t out_index = 0;
368 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
369 n = (*i) -> get_info()->n_inputs;
370 (*i)->connect_and_run (_session.get_silent_buffers (ChanCount(DataType::AUDIO, n)), in_index, out_index, nframes, offset);
376 PluginInsert::run (BufferSet& bufs, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset)
380 if (_session.transport_rolling()) {
381 automation_run (bufs, nframes, offset);
383 connect_and_run (bufs, nframes, offset, false);
386 uint32_t in = _plugins[0]->get_info()->n_inputs;
387 uint32_t out = _plugins[0]->get_info()->n_outputs;
391 /* not active, but something has make up for any channel count increase */
393 for (uint32_t n = out - in; n < out; ++n) {
394 memcpy (bufs.get_audio(n).data(nframes, offset), bufs.get_audio(in - 1).data(nframes, offset), sizeof (Sample) * nframes);
398 bufs.count().set(DataType::AUDIO, out);
403 PluginInsert::set_parameter (uint32_t port, float val)
405 /* the others will be set from the event triggered by this */
407 _plugins[0]->set_parameter (port, val);
409 if (automation_list (port).automation_write()) {
410 automation_list (port).add (_session.audible_frame(), val);
413 _session.set_dirty();
417 PluginInsert::automation_run (BufferSet& bufs, jack_nframes_t nframes, jack_nframes_t offset)
419 ControlEvent next_event (0, 0.0f);
420 jack_nframes_t now = _session.transport_frame ();
421 jack_nframes_t end = now + nframes;
423 Glib::Mutex::Lock lm (_automation_lock, Glib::TRY_LOCK);
426 connect_and_run (bufs, nframes, offset, false);
430 if (!find_next_event (now, end, next_event)) {
432 /* no events have a time within the relevant range */
434 connect_and_run (bufs, nframes, offset, true, now);
440 jack_nframes_t cnt = min (((jack_nframes_t) floor (next_event.when) - now), nframes);
442 connect_and_run (bufs, cnt, offset, true, now);
448 if (!find_next_event (now, end, next_event)) {
453 /* cleanup anything that is left to do */
456 connect_and_run (bufs, nframes, offset, true, now);
461 PluginInsert::default_parameter_value (uint32_t port)
463 if (_plugins.empty()) {
464 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
469 return _plugins[0]->default_value (port);
473 PluginInsert::set_port_automation_state (uint32_t port, AutoState s)
475 if (port < _plugins[0]->parameter_count()) {
477 AutomationList& al = automation_list (port);
479 if (s != al.automation_state()) {
480 al.set_automation_state (s);
481 last_automation_snapshot = 0;
482 _session.set_dirty ();
488 PluginInsert::get_port_automation_state (uint32_t port)
490 if (port < _plugins[0]->parameter_count()) {
491 return automation_list (port).automation_state();
498 PluginInsert::protect_automation ()
500 set<uint32_t> automated_params;
502 what_has_automation (automated_params);
504 for (set<uint32_t>::iterator i = automated_params.begin(); i != automated_params.end(); ++i) {
506 AutomationList& al = automation_list (*i);
508 switch (al.automation_state()) {
511 al.set_automation_state (Off);
519 boost::shared_ptr<Plugin>
520 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
522 boost::shared_ptr<LadspaPlugin> lp;
524 boost::shared_ptr<VSTPlugin> vp;
526 #ifdef HAVE_AUDIOUNITS
527 boost::shared_ptr<AUPlugin> ap;
530 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
531 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
533 } else if ((vp = boost::dynamic_pointer_cast<VSTPlugin> (other)) != 0) {
534 return boost::shared_ptr<Plugin> (new VSTPlugin (*vp));
536 #ifdef HAVE_AUDIOUNITS
537 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
538 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
542 fatal << string_compose (_("programming error: %1"),
543 X_("unknown plugin type in PluginInsert::plugin_factory"))
546 return boost::shared_ptr<Plugin> ((Plugin*) 0);
550 PluginInsert::compute_output_streams (int32_t cnt) const
552 return _plugins[0]->get_info()->n_outputs * cnt;
556 PluginInsert::configure_io (int32_t magic, int32_t in, int32_t out)
558 return set_count (magic);
562 PluginInsert::can_support_input_configuration (int32_t in) const
564 int32_t outputs = _plugins[0]->get_info()->n_outputs;
565 int32_t inputs = _plugins[0]->get_info()->n_inputs;
569 /* instrument plugin, always legal, but it throws
570 away any existing active streams.
576 if (outputs == 1 && inputs == 1) {
577 /* mono plugin, replicate as needed */
586 if ((inputs < in) && (inputs % in == 0)) {
588 /* number of inputs is a factor of the requested input
589 configuration, so we can replicate.
601 PluginInsert::get_state(void)
607 PluginInsert::state (bool full)
610 XMLNode *node = new XMLNode("Insert");
612 node->add_child_nocopy (Redirect::state (full));
614 node->add_property ("type", _plugins[0]->state_node_name());
615 snprintf(buf, sizeof(buf), "%s", _plugins[0]->name());
616 node->add_property("id", string(buf));
617 if (_plugins[0]->state_node_name() == "ladspa") {
619 snprintf (buf, sizeof (buf), "%ld", _plugins[0]->get_info()->unique_id);
620 node->add_property("unique-id", string(buf));
622 node->add_property("count", string_compose("%1", _plugins.size()));
623 node->add_child_nocopy (_plugins[0]->get_state());
625 /* add port automation state */
626 XMLNode *autonode = new XMLNode(port_automation_node_name);
627 set<uint32_t> automatable = _plugins[0]->automatable();
629 for (set<uint32_t>::iterator x = automatable.begin(); x != automatable.end(); ++x) {
631 XMLNode* child = new XMLNode("port");
632 snprintf(buf, sizeof(buf), "%" PRIu32, *x);
633 child->add_property("number", string(buf));
636 snprintf(buf, sizeof(buf), "0x%x", automation_list (*x).automation_state ());
638 snprintf(buf, sizeof(buf), "0x%x", ARDOUR::Off);
640 child->add_property("auto", string(buf));
642 autonode->add_child_nocopy (*child);
645 node->add_child_nocopy (*autonode);
651 PluginInsert::set_state(const XMLNode& node)
653 XMLNodeList nlist = node.children();
654 XMLNodeIterator niter;
655 XMLPropertyList plist;
656 const XMLProperty *prop;
658 ARDOUR::PluginType type;
660 if ((prop = node.property ("type")) == 0) {
661 error << _("XML node describing insert is missing the `type' field") << endmsg;
665 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
666 type = ARDOUR::LADSPA;
667 } else if (prop->value() == X_("vst")) {
670 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
676 prop = node.property ("unique-id");
678 unique = atol(prop->value().c_str());
681 if ((prop = node.property ("id")) == 0) {
682 error << _("XML node describing insert is missing the `id' field") << endmsg;
686 boost::shared_ptr<Plugin> plugin;
689 plugin = find_plugin (_session, "", unique, type);
691 plugin = find_plugin (_session, prop->value(), 0, type);
695 error << string_compose(_("Found a reference to a plugin (\"%1\") that is unknown.\n"
696 "Perhaps it was removed or moved since it was last used."), prop->value())
703 if ((prop = node.property ("count")) != 0) {
704 sscanf (prop->value().c_str(), "%u", &count);
707 if (_plugins.size() != count) {
709 _plugins.push_back (plugin);
711 for (uint32_t n=1; n < count; ++n) {
712 _plugins.push_back (plugin_factory (plugin));
716 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
717 if ((*niter)->name() == plugin->state_node_name()) {
718 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
719 (*i)->set_state (**niter);
725 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
726 if ((*niter)->name() == Redirect::state_node_name) {
727 Redirect::set_state (**niter);
732 if (niter == nlist.end()) {
733 error << _("XML node describing insert is missing a Redirect node") << endmsg;
737 if (niter == nlist.end()) {
738 error << string_compose(_("XML node describing a plugin insert is missing the `%1' information"), plugin->state_node_name()) << endmsg;
742 /* look for port automation node */
744 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
745 if ((*niter)->name() == port_automation_node_name) {
748 XMLNodeConstIterator iter;
753 cnodes = (*niter)->children ("port");
755 for(iter = cnodes.begin(); iter != cnodes.end(); ++iter){
759 if ((cprop = child->property("number")) != 0) {
760 port = cprop->value().c_str();
762 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
766 sscanf (port, "%" PRIu32, &port_id);
768 if (port_id >= _plugins[0]->parameter_count()) {
769 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
773 if ((cprop = child->property("auto")) != 0) {
775 sscanf (cprop->value().c_str(), "0x%x", &x);
776 automation_list (port_id).set_automation_state (AutoState (x));
784 if (niter == nlist.end()) {
785 warning << string_compose(_("XML node describing a port automation is missing the `%1' information"), port_automation_node_name) << endmsg;
788 // The name of the PluginInsert comes from the plugin, nothing else
789 set_name(plugin->get_info()->name,this);
795 PluginInsert::describe_parameter (uint32_t what)
797 return _plugins[0]->describe_parameter (what);
801 PluginInsert::latency()
803 return _plugins[0]->latency ();
807 PluginInsert::store_state (PluginInsertState& state) const
809 Redirect::store_state (state);
810 _plugins[0]->store_state (state.plugin_state);
814 PluginInsert::restore_state (StateManager::State& state)
816 PluginInsertState* pistate = dynamic_cast<PluginInsertState*> (&state);
818 Redirect::restore_state (state);
820 _plugins[0]->restore_state (pistate->plugin_state);
826 PluginInsert::state_factory (std::string why) const
828 PluginInsertState* state = new PluginInsertState (why);
830 store_state (*state);
836 PluginInsert::type ()
838 boost::shared_ptr<LadspaPlugin> lp;
840 boost::shared_ptr<VSTPlugin> vp;
842 #ifdef HAVE_AUDIOUNITS
843 boost::shared_ptr<AUPlugin> ap;
846 PluginPtr other = plugin ();
848 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
849 return ARDOUR::LADSPA;
851 } else if ((vp = boost::dynamic_pointer_cast<VSTPlugin> (other)) != 0) {
854 #ifdef HAVE_AUDIOUNITS
855 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
856 return ARDOUR::AudioUnit;
860 return (ARDOUR::PluginType) 0;
864 /***************************************************************
865 Port inserts: send output to a port, pick up input at a port
866 ***************************************************************/
868 PortInsert::PortInsert (Session& s, Placement p)
869 : Insert (s, p, 1, -1, 1, -1)
872 save_state (_("initial state"));
873 RedirectCreated (this); /* EMIT SIGNAL */
876 PortInsert::PortInsert (const PortInsert& other)
877 : Insert (other._session, other.placement(), 1, -1, 1, -1)
880 save_state (_("initial state"));
881 RedirectCreated (this); /* EMIT SIGNAL */
887 if (add_input_port ("", this)) {
888 error << _("PortInsert: cannot add input port") << endmsg;
889 throw failed_constructor();
892 if (add_output_port ("", this)) {
893 error << _("PortInsert: cannot add output port") << endmsg;
894 throw failed_constructor();
898 PortInsert::PortInsert (Session& s, const XMLNode& node)
899 : Insert (s, "will change", PreFader)
901 if (set_state (node)) {
902 throw failed_constructor();
905 RedirectCreated (this); /* EMIT SIGNAL */
908 PortInsert::~PortInsert ()
914 PortInsert::run (BufferSet& bufs, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset)
916 if (n_outputs().get(_default_type) == 0) {
921 /* deliver silence */
922 silence (nframes, offset);
926 deliver_output(bufs, start_frame, end_frame, nframes, offset);
928 collect_input(bufs, nframes, offset);
932 PortInsert::get_state(void)
938 PortInsert::state (bool full)
940 XMLNode *node = new XMLNode("Insert");
942 node->add_child_nocopy (Redirect::state(full));
943 node->add_property("type", "port");
949 PortInsert::set_state(const XMLNode& node)
951 XMLNodeList nlist = node.children();
952 XMLNodeIterator niter;
953 XMLPropertyList plist;
954 const XMLProperty *prop;
956 if ((prop = node.property ("type")) == 0) {
957 error << _("XML node describing insert is missing the `type' field") << endmsg;
961 if (prop->value() != "port") {
962 error << _("non-port insert XML used for port plugin insert") << endmsg;
966 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
967 if ((*niter)->name() == Redirect::state_node_name) {
968 Redirect::set_state (**niter);
973 if (niter == nlist.end()) {
974 error << _("XML node describing insert is missing a Redirect node") << endmsg;
982 PortInsert::latency()
984 /* because we deliver and collect within the same cycle,
985 all I/O is necessarily delayed by at least frames_per_cycle().
987 if the return port for insert has its own latency, we
988 need to take that into account too.
991 return _session.engine().frames_per_cycle() + input_latency();
995 PortInsert::can_support_input_configuration (int32_t in) const
997 if (input_maximum() == ChanCount::INFINITE && output_maximum() == ChanCount::INFINITE) {
999 /* not configured yet */
1001 return 1; /* we can support anything the first time we're asked */
1005 /* the "input" config for a port insert corresponds to how
1006 many output ports it will have.
1009 if (output_maximum().get(_default_type) == static_cast<uint32_t>(in)) {
1018 PortInsert::configure_io (int32_t ignored_magic, int32_t in, int32_t out)
1020 /* do not allow configuration to be changed outside the range of
1021 the last request config. or something like that.
1025 /* this is a bit odd:
1027 the number of inputs we are required to handle corresponds
1028 to the number of output ports we need.
1030 the number of outputs we are required to have corresponds
1031 to the number of input ports we need.
1034 set_output_maximum (in);
1035 set_output_minimum (in);
1036 set_input_maximum (out);
1037 set_input_minimum (out);
1040 in = n_outputs ().get(_default_type);
1044 out = n_inputs ().get(_default_type);
1048 return ensure_io (ChanCount(_default_type, in), ChanCount(_default_type, out), false, this);
1052 PortInsert::compute_output_streams (int32_t cnt) const
1054 /* puzzling, eh? think about it ... */
1055 return n_inputs ().get(_default_type);
1059 PortInsert::output_streams() const
1065 PortInsert::input_streams() const
1067 return n_outputs ();