#include "pbd/failed_constructor.h"
#include "pbd/xml++.h"
-#include "pbd/convert.h"
+#include "pbd/types_convert.h"
#include "ardour/audio_buffer.h"
#include "ardour/automation_list.h"
#include "ardour/lxvst_plugin.h"
#endif
+#ifdef MACVST_SUPPORT
+#include "ardour/mac_vst_plugin.h"
+#endif
+
#ifdef AUDIOUNIT_SUPPORT
#include "ardour/audio_unit.h"
#endif
, _strict_io (false)
, _custom_cfg (false)
, _maps_from_state (false)
+ , _latency_changed (false)
, _bypass_port (UINT32_MAX)
{
/* the first is the master */
PluginInsert::~PluginInsert ()
{
+ for (CtrlOutMap::const_iterator i = _control_outputs.begin(); i != _control_outputs.end(); ++i) {
+ boost::dynamic_pointer_cast<ReadOnlyControl>(i->second)->drop_references ();
+ }
}
void
}
bool
-PluginInsert::needs_midi_input() const
+PluginInsert::is_instrument() const
{
PluginInfoPtr pip = _plugins[0]->get_info();
- if (pip->needs_midi_input ()) {
+ if (pip->is_instrument ()) {
return true;
}
- return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
+ return pip->n_inputs.n_midi () != 0 && pip->n_outputs.n_audio () > 0 && pip->n_inputs.n_audio () == 0;
}
bool
return false;
}
}
- if (!needs_midi_input ()) {
+
+ if (ppc.size () == 1 && ppc.find (0) != ppc.end () && !_plugins[0]->get_info ()->reconfigurable_io ()) {
+ // some midi-sequencer (e.g. QMidiArp) or other midi-out plugin
+ // pretending to be an "Instrument"
+ return false;
+ }
+
+ if (!is_instrument ()) {
return false;
}
return true;
set<Evoral::Parameter> a = _plugins.front()->automatable ();
for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
- if (!plugin->parameter_is_control (i) || !plugin->parameter_is_input (i)) {
+ if (!plugin->parameter_is_control (i)) {
continue;
}
- Evoral::Parameter param (PluginAutomation, 0, i);
ParameterDescriptor desc;
plugin->get_parameter_descriptor(i, desc);
+ if (!plugin->parameter_is_input (i)) {
+ _control_outputs[i] = boost::shared_ptr<ReadOnlyControl> (new ReadOnlyControl (plugin, desc, i));
+ continue;
+ }
+ Evoral::Parameter param (PluginAutomation, 0, i);
+
const bool automatable = a.find(param) != a.end();
if (automatable) {
if (Variant::type_is_numeric(desc.datatype)) {
list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
}
- add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
+ boost::shared_ptr<AutomationControl> c (new PluginPropertyControl(this, param, desc, list));
+ if (!Variant::type_is_numeric(desc.datatype)) {
+ c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
+ }
+ add_control (c);
}
}
_bypass_port = plugin->designated_bypass_port ();
+ /* special case VST effSetBypass */
+ if (_bypass_port == UINT32_MAX -1) {
+ // emulate VST Bypass
+ Evoral::Parameter param (PluginAutomation, 0, _bypass_port);
+ ParameterDescriptor desc;
+ desc.label = _("Plugin Enable");
+ desc.toggled = true;
+ desc.normal = 1;
+ desc.lower = 0;
+ desc.upper = 1;
+ boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
+ boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
+ add_control (c);
+ }
+
if (_bypass_port != UINT32_MAX) {
boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
if (0 == (ac->flags () & Controllable::NotAutomatable)) {
ac->Changed.connect_same_thread (*this, boost::bind (&PluginInsert::enable_changed, this));
}
}
+ plugin->PresetPortSetValue.connect_same_thread (*this, boost::bind (&PluginInsert::preset_load_set_value, this, _1, _2));
}
+
/** Called when something outside of this host has modified a plugin
* parameter. Responsible for propagating the change to two places:
*
}
Processor::activate ();
+ /* when setting state e.g ProcessorBox::paste_processor_state ()
+ * the plugin is not yet owned by a route.
+ * but no matter. Route::add_processors() will call activate () again
+ */
+ if (!owner ()) {
+ return;
+ }
if (_plugin_signal_latency != signal_latency ()) {
_plugin_signal_latency = signal_latency ();
latency_changed ();
activate ();
}
boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, _bypass_port));
- ac->set_value (yn ? 1.0 : 0.0, Controllable::NoGroup);
+ const double val = yn ? 1.0 : 0.0;
+ ac->set_value (val, Controllable::NoGroup);
+
+#ifdef ALLOW_VST_BYPASS_TO_FAIL // yet unused, see also vst_plugin.cc
+ /* special case VST.. bypass may fail */
+ if (_bypass_port == UINT32_MAX - 1) {
+ /* check if bypass worked */
+ if (ac->get_value () != val) {
+ warning << _("PluginInsert: VST Bypass failed, falling back to host bypass.") << endmsg;
+ // set plugin to enabled (not-byassed)
+ ac->set_value (1.0, Controllable::NoGroup);
+ // ..and use host-provided hard-bypass
+ if (yn) {
+ activate ();
+ } else {
+ deactivate ();
+ }
+ return;
+ }
+ }
+#endif
ActiveChanged ();
}
}
BypassableChanged ();
}
+bool
+PluginInsert::write_immediate_event (size_t size, const uint8_t* buf)
+{
+ bool rv = true;
+ for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
+ if (!(*i)->write_immediate_event (size, buf)) {
+ rv = false;
+ }
+ }
+ return rv;
+}
+
+void
+PluginInsert::preset_load_set_value (uint32_t p, float v)
+{
+ boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, p));
+ if (!ac) {
+ return;
+ }
+
+ if (ac->automation_state() & Play) {
+ return;
+ }
+
+ start_touch (p);
+ ac->set_value (v, Controllable::NoGroup);
+ end_touch (p);
+}
+
void
PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const
{
void
PluginInsert::silence (framecnt_t nframes, framepos_t start_frame)
{
+ automation_run (start_frame, nframes); // evaluate automation only
+
if (!active ()) {
+ // XXX delaybuffers need to be offset by nframes
return;
}
/* run as normal if we are active or moving from inactive to active */
if (_session.transport_rolling() || _session.bounce_processing()) {
- automation_run (bufs, start_frame, end_frame, speed, nframes);
+ automate_and_run (bufs, start_frame, end_frame, speed, nframes);
} else {
- connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, false);
+ Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
+ connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, lm.locked());
}
} else {
+ // XXX should call ::silence() to run plugin(s) for consistent load.
+ // We'll need to change this anyway when bypass can be automated
bypass (bufs, nframes);
+ automation_run (start_frame, nframes); // evaluate automation only
_delaybuffers.flush ();
}
}
void
-PluginInsert::automation_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes)
+PluginInsert::automate_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes)
{
Evoral::ControlEvent next_event (0, 0.0f);
framecnt_t offset = 0;
#ifdef LXVST_SUPPORT
boost::shared_ptr<LXVSTPlugin> lxvp;
#endif
+#ifdef MACVST_SUPPORT
+ boost::shared_ptr<MacVSTPlugin> mvp;
+#endif
#ifdef AUDIOUNIT_SUPPORT
boost::shared_ptr<AUPlugin> ap;
#endif
} else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
#endif
+#ifdef MACVST_SUPPORT
+ } else if ((mvp = boost::dynamic_pointer_cast<MacVSTPlugin> (other)) != 0) {
+ return boost::shared_ptr<Plugin> (new MacVSTPlugin (*mvp));
+#endif
#ifdef AUDIOUNIT_SUPPORT
} else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
&& _in_map.size() == _out_map.size()
&& _in_map.size() == get_count ()
) {
- assert (_maps_from_state == false);
/* If the configuration has not changed, keep the mapping */
mapping_changed = sanitize_maps ();
} else if (_match.custom_cfg && _configured) {
- assert (_maps_from_state == false);
/* don't touch the map in manual mode */
mapping_changed = sanitize_maps ();
} else {
m.strict_io = true;
/* special case MIDI instruments */
- if (needs_midi_input ()) {
+ if (is_instrument ()) {
// output = midi-bypass + at most master-out channels.
ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
max_out.set (DataType::MIDI, out.get(DataType::MIDI));
uint32_t f = 0;
bool can_replicate = true;
- for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
// ignore side-chains
uint32_t nin = ns_inputs.get (*t);
{
XMLNode& node = Processor::state (full);
- node.add_property("type", _plugins[0]->state_node_name());
- node.add_property("unique-id", _plugins[0]->unique_id());
- node.add_property("count", string_compose("%1", _plugins.size()));
+ node.set_property("type", _plugins[0]->state_node_name());
+ node.set_property("unique-id", _plugins[0]->unique_id());
+ node.set_property("count", (uint32_t)_plugins.size());
/* remember actual i/o configuration (for later placeholder
* in case the plugin goes missing) */
node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
/* save custom i/o config */
- node.add_property("custom", _custom_cfg ? "yes" : "no");
+ node.set_property("custom", _custom_cfg);
for (uint32_t pc = 0; pc < get_count(); ++pc) {
char tmp[128];
snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
if ((*iter)->name() == Controllable::xml_node_name) {
- XMLProperty const * prop;
uint32_t p = (uint32_t)-1;
#ifdef LV2_SUPPORT
- if ((prop = (*iter)->property (X_("symbol"))) != 0) {
+ std::string str;
+ if ((*iter)->get_property (X_("symbol"), str)) {
boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
if (lv2plugin) {
- p = lv2plugin->port_index(prop->value().c_str());
+ p = lv2plugin->port_index(str.c_str());
}
}
#endif
- if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
- p = atoi (prop->value());
+ if (p == (uint32_t)-1) {
+ (*iter)->get_property (X_("parameter"), p);
}
if (p != (uint32_t)-1) {
XMLNodeList nlist = node.children();
XMLNodeIterator niter;
XMLPropertyList plist;
- XMLProperty const * prop;
ARDOUR::PluginType type;
- if ((prop = node.property ("type")) == 0) {
+ std::string str;
+ if (!node.get_property ("type", str)) {
error << _("XML node describing plugin is missing the `type' field") << endmsg;
return -1;
}
- if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
+ if (str == X_("ladspa") || str == X_("Ladspa")) { /* handle old school sessions */
type = ARDOUR::LADSPA;
- } else if (prop->value() == X_("lv2")) {
+ } else if (str == X_("lv2")) {
type = ARDOUR::LV2;
- } else if (prop->value() == X_("windows-vst")) {
+ } else if (str == X_("windows-vst")) {
type = ARDOUR::Windows_VST;
- } else if (prop->value() == X_("lxvst")) {
+ } else if (str == X_("lxvst")) {
type = ARDOUR::LXVST;
- } else if (prop->value() == X_("audiounit")) {
+ } else if (str == X_("mac-vst")) {
+ type = ARDOUR::MacVST;
+ } else if (str == X_("audiounit")) {
type = ARDOUR::AudioUnit;
- } else if (prop->value() == X_("luaproc")) {
+ } else if (str == X_("luaproc")) {
type = ARDOUR::Lua;
} else {
- error << string_compose (_("unknown plugin type %1 in plugin insert state"),
- prop->value())
- << endmsg;
+ error << string_compose (_("unknown plugin type %1 in plugin insert state"), str) << endmsg;
return -1;
}
- prop = node.property ("unique-id");
+ XMLProperty const * prop = node.property ("unique-id");
if (prop == 0) {
#ifdef WINDOWS_VST_SUPPORT
- /* older sessions contain VST plugins with only an "id" field.
- */
-
+ /* older sessions contain VST plugins with only an "id" field. */
if (type == ARDOUR::Windows_VST) {
prop = node.property ("id");
}
#ifdef LXVST_SUPPORT
/*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
-
if (type == ARDOUR::LXVST) {
prop = node.property ("id");
}
#endif
+
/* recheck */
if (prop == 0) {
}
boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
+ bool any_vst = false;
- /* treat linux and windows VST plugins equivalent if they have the same uniqueID
+ /* treat VST plugins equivalent if they have the same uniqueID
* allow to move sessions windows <> linux */
#ifdef LXVST_SUPPORT
- if (plugin == 0 && type == ARDOUR::Windows_VST) {
+ if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::MacVST)) {
type = ARDOUR::LXVST;
plugin = find_plugin (_session, prop->value(), type);
+ if (plugin) { any_vst = true; }
}
#endif
#ifdef WINDOWS_VST_SUPPORT
- if (plugin == 0 && type == ARDOUR::LXVST) {
+ if (plugin == 0 && (type == ARDOUR::LXVST || type == ARDOUR::MacVST)) {
type = ARDOUR::Windows_VST;
plugin = find_plugin (_session, prop->value(), type);
+ if (plugin) { any_vst = true; }
+ }
+#endif
+
+#ifdef MACVST_SUPPORT
+ if (plugin == 0 && (type == ARDOUR::Windows_VST || type == ARDOUR::LXVST)) {
+ type = ARDOUR::MacVST;
+ plugin = find_plugin (_session, prop->value(), type);
+ if (plugin) { any_vst = true; }
}
#endif
set_control_ids (node, version);
}
- if ((prop = node.property ("count")) != 0) {
- sscanf (prop->value().c_str(), "%u", &count);
- }
+ node.get_property ("count", count);
if (_plugins.size() != count) {
for (uint32_t n = 1; n < count; ++n) {
PBD::ID new_id = this->id();
PBD::ID old_id = this->id();
- if ((prop = node.property ("id")) != 0) {
- old_id = prop->value ();
- }
+ node.get_property ("id", old_id);
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
and set all plugins to the same state.
*/
- if ((*niter)->name() == plugin->state_node_name()) {
+ if ( ((*niter)->name() == plugin->state_node_name())
+ || (any_vst && ((*niter)->name() == "lxvst" || (*niter)->name() == "windows-vst" || (*niter)->name() == "mac-vst"))
+ ) {
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
/* Plugin state can include external files which are named after the ID.
}
}
+ /* when copying plugin state, notify UI */
+ for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li) {
+ boost::shared_ptr<PBD::Controllable> c = boost::dynamic_pointer_cast<PBD::Controllable> (li->second);
+ if (c) {
+ c->Changed (false, Controllable::NoGroup); /* EMIT SIGNAL */
+ }
+ }
+
break;
}
}
set_parameter_state_2X (node, version);
}
- if ((prop = node.property (X_("custom"))) != 0) {
- _custom_cfg = string_is_affirmative (prop->value());
- }
+ node.get_property (X_("custom"), _custom_cfg);
uint32_t in_maps = 0;
uint32_t out_maps = 0;
if (!_sidechain) {
add_sidechain (0);
}
- _sidechain->set_state (**i, version);
+ if (!regenerate_xml_or_string_ids ()) {
+ _sidechain->set_state (**i, version);
+ }
}
}
}
}
+void
+PluginInsert::set_owner (SessionObject* o)
+{
+ Processor::set_owner (o);
+ for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
+ (*i)->set_owner (o);
+ }
+}
+
void
PluginInsert::set_state_dir (const std::string& d)
{
}
XMLNodeList cnodes;
- XMLProperty const * cprop;
XMLNodeConstIterator iter;
XMLNode *child;
- const char *port;
uint32_t port_id;
cnodes = (*niter)->children ("port");
child = *iter;
- if ((cprop = child->property("number")) != 0) {
- port = cprop->value().c_str();
- } else {
+ if (!child->get_property("number", port_id)) {
warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
continue;
}
- sscanf (port, "%" PRIu32, &port_id);
-
if (port_id >= _plugins[0]->parameter_count()) {
warning << _("PluginInsert: Auto: port id out of range") << endmsg;
continue;
if (c && c->alist()) {
if (!child->children().empty()) {
c->alist()->set_state (*child->children().front(), version);
-
- /* In some cases 2.X saves lists with min_yval and max_yval
- being FLT_MIN and FLT_MAX respectively. This causes problems
- in A3 because these min/max values are used to compute
- where GUI control points should be drawn. If we see such
- values, `correct' them to the min/max of the appropriate
- parameter.
- */
-
- float min_y = c->alist()->get_min_y ();
- float max_y = c->alist()->get_max_y ();
-
- ParameterDescriptor desc;
- _plugins.front()->get_parameter_descriptor (port_id, desc);
-
- if (min_y == FLT_MIN) {
- min_y = desc.lower;
- }
-
- if (max_y == FLT_MAX) {
- max_y = desc.upper;
- }
-
- c->alist()->set_yrange (min_y, max_y);
}
} else {
error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
}
}
+boost::shared_ptr<ReadOnlyControl>
+PluginInsert::control_output (uint32_t num) const
+{
+ CtrlOutMap::const_iterator i = _control_outputs.find (num);
+ if (i == _control_outputs.end ()) {
+ return boost::shared_ptr<ReadOnlyControl> ();
+ } else {
+ return (*i).second;
+ }
+}
string
PluginInsert::describe_parameter (Evoral::Parameter param)
, _plugin (p)
{
if (alist()) {
- alist()->reset_default (desc.normal);
if (desc.toggled) {
list->set_interpolation(Evoral::ControlList::Discrete);
}
XMLNode&
PluginInsert::PluginControl::get_state ()
{
- stringstream ss;
-
XMLNode& node (AutomationControl::get_state());
- ss << parameter().id();
- node.add_property (X_("parameter"), ss.str());
+ node.set_property (X_("parameter"), parameter().id());
#ifdef LV2_SUPPORT
boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
if (lv2plugin) {
- node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
+ node.set_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
}
#endif
: AutomationControl (p->session(), param, desc, list)
, _plugin (p)
{
- if (alist()) {
- alist()->set_yrange (desc.lower, desc.upper);
- alist()->reset_default (desc.normal);
- }
}
void
XMLNode&
PluginInsert::PluginPropertyControl::get_state ()
{
- stringstream ss;
-
XMLNode& node (AutomationControl::get_state());
- ss << parameter().id();
- node.add_property (X_("property"), ss.str());
+ node.set_property (X_("property"), parameter().id());
node.remove_property (X_("value"));
return node;
assert (out == internal_output_streams ());
}
ret->configure_io (internal_input_streams (), out);
+ ret->set_owner (_owner);
_impulseAnalysisPlugin = ret;
} else {
ret = _impulseAnalysisPlugin.lock();
PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
{
plugin->set_insert_id (this->id());
+ plugin->set_owner (_owner);
if (_plugins.empty()) {
/* first (and probably only) plugin instance - connect to relevant signals */
}
}
}
-#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT)
boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
if (vst) {
vst->set_insert (this, _plugins.size ());
void
PluginInsert::start_touch (uint32_t param_id)
{
- boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
- if (ac) {
- ac->start_touch (session().audible_frame());
- }
+ boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
+ if (ac) {
+ // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0
+ ac->start_touch (session().audible_frame());
+ }
}
void
PluginInsert::end_touch (uint32_t param_id)
{
- boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
- if (ac) {
- ac->stop_touch (true, session().audible_frame());
- }
+ boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
+ if (ac) {
+ // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0
+ ac->stop_touch (session().audible_frame());
+ }
}
std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
projects / ardour.git / blobdiff