#include <ardour/route.h>
#include <ardour/ladspa_plugin.h>
#include <ardour/buffer_set.h>
-#include <ardour/automation_event.h>
+#include <ardour/automation_list.h>
+
+#ifdef HAVE_SLV2
+#include <ardour/lv2_plugin.h>
+#endif
#ifdef VST_SUPPORT
#include <ardour/vst_plugin.h>
throw failed_constructor();
}
- // set_automatable ();
+ set_automatable ();
{
Glib::Mutex::Lock em (_session.engine().process_lock());
}
void
-PluginInsert::auto_state_changed (Parameter which)
+PluginInsert::auto_state_changed (Evoral::Parameter which)
{
if (which.type() != PluginAutomation)
return;
- boost::shared_ptr<AutomationControl> c = control (which);
+ boost::shared_ptr<AutomationControl> c
+ = boost::dynamic_pointer_cast<AutomationControl>(data().control (which));
- if (c && c->list()->automation_state() != Off) {
+ if (c && ((AutomationList*)c->list().get())->automation_state() != Off) {
_plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
}
}
ChanCount
PluginInsert::output_streams() const
{
- if (_configured)
- return output_for_input_configuration(_configured_input);
- else
- return natural_output_streams();
+ ChanCount out = _plugins.front()->get_info()->n_outputs;
+
+ if (out == ChanCount::INFINITE) {
+
+ return _plugins.front()->output_streams ();
+
+ } else {
+
+ out.set_audio (out.n_audio() * _plugins.size());
+ out.set_midi (out.n_midi() * _plugins.size());
+
+ return out;
+ }
}
ChanCount
PluginInsert::input_streams() const
{
- if (_configured)
- return _configured_input;
- else
- return natural_input_streams();
+ ChanCount in = _plugins[0]->get_info()->n_inputs;
+
+ if (in == ChanCount::INFINITE) {
+ return _plugins[0]->input_streams ();
+ } else {
+ in.set_audio (in.n_audio() * _plugins.size());
+ in.set_midi (in.n_midi() * _plugins.size());
+
+ return in;
+ }
}
ChanCount
void
PluginInsert::set_automatable ()
{
- set<Parameter> a = _plugins.front()->automatable ();
+ set<Evoral::Parameter> a = _plugins.front()->automatable ();
Plugin::ParameterDescriptor desc;
- for (set<Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
+ for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
if (i->type() == PluginAutomation) {
can_automate (*i);
_plugins.front()->get_parameter_descriptor(i->id(), desc);
- boost::shared_ptr<AutomationList> list(new AutomationList(
- *i,
- //(desc.min_unbound ? FLT_MIN : desc.lower),
- //(desc.max_unbound ? FLT_MAX : desc.upper),
- desc.lower, desc.upper,
- _plugins.front()->default_value(i->id())));
-
- add_control(boost::shared_ptr<AutomationControl>(
- new PluginControl(*this, list)));
+ Evoral::Parameter param(*i);
+ param.set_range(desc.lower, desc.upper, _plugins.front()->default_value(i->id()));
+ boost::shared_ptr<AutomationList> list(new AutomationList(param));
+ add_control(boost::shared_ptr<AutomationControl>(new PluginControl(this, *i, list)));
}
}
}
void
-PluginInsert::parameter_changed (Parameter which, float val)
+PluginInsert::parameter_changed (Evoral::Parameter which, float val)
{
if (which.type() != PluginAutomation)
return;
uint32_t n = 0;
- for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li, ++n) {
+ for (Controls::iterator li = data().controls().begin(); li != data().controls().end(); ++li, ++n) {
- boost::shared_ptr<AutomationControl> c = li->second;
+ boost::shared_ptr<AutomationControl> c
+ = boost::dynamic_pointer_cast<AutomationControl>(li->second);
- if (c->parameter().type() == PluginAutomation && c->list()->automation_playback()) {
+ if (c->parameter().type() == PluginAutomation && c->automation_playback()) {
bool valid;
const float val = c->list()->rt_safe_eval (now, valid);
}
void
-PluginInsert::set_parameter (Parameter param, float val)
+PluginInsert::set_parameter (Evoral::Parameter param, float val)
{
if (param.type() != PluginAutomation)
return;
_plugins[0]->set_parameter (param.id(), val);
- boost::shared_ptr<AutomationControl> c = control (param);
+ boost::shared_ptr<AutomationControl> ac
+ = boost::dynamic_pointer_cast<AutomationControl>(data().control(param));
- if (c)
- c->set_value(val);
+ if (ac) {
+ ac->set_value(val);
+ } else {
+ warning << "set_parameter called for nonexistant parameter "
+ << EventTypeMap::instance().to_symbol(param) << endmsg;
+ }
_session.set_dirty();
}
float
-PluginInsert::get_parameter (Parameter param)
+PluginInsert::get_parameter (Evoral::Parameter param)
{
if (param.type() != PluginAutomation)
return 0.0;
void
PluginInsert::automation_run (BufferSet& bufs, nframes_t nframes, nframes_t offset)
{
- ControlEvent next_event (0, 0.0f);
+ Evoral::ControlEvent next_event (0, 0.0f);
nframes_t now = _session.transport_frame ();
nframes_t end = now + nframes;
- Glib::Mutex::Lock lm (_automation_lock, Glib::TRY_LOCK);
+ Glib::Mutex::Lock lm (data().control_lock(), Glib::TRY_LOCK);
if (!lm.locked()) {
connect_and_run (bufs, nframes, offset, false);
return;
}
- if (!find_next_event (now, end, next_event)) {
+ if (!data().find_next_event (now, end, next_event)) {
/* no events have a time within the relevant range */
offset += cnt;
now += cnt;
- if (!find_next_event (now, end, next_event)) {
+ if (!data().find_next_event (now, end, next_event)) {
break;
}
}
}
float
-PluginInsert::default_parameter_value (Parameter param)
+PluginInsert::default_parameter_value (const Evoral::Parameter& param)
{
if (param.type() != PluginAutomation)
return 1.0;
PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
{
boost::shared_ptr<LadspaPlugin> lp;
+#ifdef HAVE_SLV2
+ boost::shared_ptr<LV2Plugin> lv2p;
+#endif
#ifdef VST_SUPPORT
boost::shared_ptr<VSTPlugin> vp;
#endif
if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
+#ifdef HAVE_SLV2
+ } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
+ return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
+#endif
#ifdef VST_SUPPORT
} else if ((vp = boost::dynamic_pointer_cast<VSTPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new VSTPlugin (*vp));
bool
PluginInsert::configure_io (ChanCount in, ChanCount out)
{
- ChanCount matching_out = output_for_input_configuration(out);
- if (matching_out != out) {
- _configured = false;
+ if (set_count (count_for_configuration (in, out)) < 0) {
+ return false;
+ }
+
+ /* if we're running replicated plugins, each plugin has
+ the same i/o configuration and we may need to announce how many
+ output streams there are.
+
+ if we running a single plugin, we need to configure it.
+ */
+
+ if (_plugins.front()->configure_io (in, out) < 0) {
return false;
- } else {
- bool success = set_count (count_for_configuration(in, out));
- if (success)
- Processor::configure_io(in, out);
- return success;
}
+
+ return Processor::configure_io (in, out);
}
bool
-PluginInsert::can_support_input_configuration (ChanCount in) const
+PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
{
+ if (_plugins.front()->reconfigurable_io()) {
+ /* plugin has flexible I/O, so delegate to it */
+ return _plugins.front()->can_support_io_configuration (in, out);
+ }
+
ChanCount outputs = _plugins[0]->get_info()->n_outputs;
ChanCount inputs = _plugins[0]->get_info()->n_inputs;
- /* see output_for_input_configuration below */
if ((inputs.n_total() == 0)
|| (inputs.n_total() == 1 && outputs == inputs)
|| (inputs.n_total() == 1 && outputs == inputs
&& ((inputs.n_audio() == 0 && in.n_audio() == 0)
|| (inputs.n_midi() == 0 && in.n_midi() == 0)))
|| (inputs == in)) {
+ out = outputs;
return true;
}
}
}
- if (can_replicate && (in.n_total() % inputs.n_total() == 0)) {
- return true;
- } else {
+ if (!can_replicate || (in.n_total() % inputs.n_total() != 0)) {
return false;
}
-}
-
-ChanCount
-PluginInsert::output_for_input_configuration (ChanCount in) const
-{
- ChanCount outputs = _plugins[0]->get_info()->n_outputs;
- ChanCount inputs = _plugins[0]->get_info()->n_inputs;
if (inputs.n_total() == 0) {
/* instrument plugin, always legal, but throws away any existing streams */
- return outputs;
- }
-
- if (inputs.n_total() == 1 && outputs == inputs
+ out = outputs;
+ } else if (inputs.n_total() == 1 && outputs == inputs
&& ((inputs.n_audio() == 0 && in.n_audio() == 0)
- || (inputs.n_midi() == 0 && in.n_midi() == 0))) {
- /* mono plugin, replicate as needed to match in */
- return in;
- }
-
- if (inputs == in) {
+ || (inputs.n_midi() == 0 && in.n_midi() == 0))) {
+ /* mono, single-typed plugin, replicate as needed to match in */
+ out = in;
+ } else if (inputs == in) {
/* exact match */
- return outputs;
- }
-
- bool can_replicate = true;
-
- /* if number of inputs is a factor of the requested input
- configuration for every type, we can replicate.
- */
- for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- if (inputs.get(*t) >= in.get(*t) || (in.get(*t) % inputs.get(*t) != 0)) {
- can_replicate = false;
- break;
- }
- }
-
- if (can_replicate && (inputs.n_total() % in.n_total() == 0)) {
- ChanCount output;
-
+ out = outputs;
+ } else {
+ /* replicate - note that we've already verified that
+ the replication count is constant across all data types.
+ */
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- output.set(*t, outputs.get(*t) * (in.get(*t) / inputs.get(*t)));
+ out.set (*t, outputs.get(*t) * (in.get(*t) / inputs.get(*t)));
}
-
- return output;
}
-
- /* sorry */
- return ChanCount();
+
+ return true;
}
/* Number of plugin instances required to support a given channel configuration.
int32_t
PluginInsert::count_for_configuration (ChanCount in, ChanCount out) const
{
+ if (_plugins.front()->reconfigurable_io()) {
+ /* plugin has flexible I/O, so the answer is always 1 */
+ /* this could change if we ever decide to replicate AU's */
+ return 1;
+ }
+
// FIXME: take 'out' into consideration
ChanCount outputs = _plugins[0]->get_info()->n_outputs;
/* add port automation state */
XMLNode *autonode = new XMLNode(port_automation_node_name);
- set<Parameter> automatable = _plugins[0]->automatable();
+ set<Evoral::Parameter> automatable = _plugins[0]->automatable();
- for (set<Parameter>::iterator x = automatable.begin(); x != automatable.end(); ++x) {
+ for (set<Evoral::Parameter>::iterator x = automatable.begin(); x != automatable.end(); ++x) {
/*XMLNode* child = new XMLNode("port");
snprintf(buf, sizeof(buf), "%" PRIu32, *x);
child->add_child_nocopy (automation_list (*x).state (full));
autonode->add_child_nocopy (*child);
*/
- autonode->add_child_nocopy (control(*x)->list()->state (full));
+ autonode->add_child_nocopy (((AutomationList*)data().control(*x)->list().get())->state (full));
}
node.add_child_nocopy (*autonode);
if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
type = ARDOUR::LADSPA;
+ } else if (prop->value() == X_("lv2")) {
+ type = ARDOUR::LV2;
} else if (prop->value() == X_("vst")) {
type = ARDOUR::VST;
} else {
continue;
}
+ boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
+ data().control(Evoral::Parameter(PluginAutomation, port_id), true));
+
if (!child->children().empty()) {
- control (Parameter(PluginAutomation, port_id), true)->list()->set_state (*child->children().front());
+ c->alist()->set_state (*child->children().front());
} else {
if ((cprop = child->property("auto")) != 0) {
int x;
sscanf (cprop->value().c_str(), "0x%x", &x);
- control (Parameter(PluginAutomation, port_id), true)->list()->set_automation_state (AutoState (x));
+ c->alist()->set_automation_state (AutoState (x));
} else {
/* missing */
- control (Parameter(PluginAutomation, port_id), true)->list()->set_automation_state (Off);
+ c->alist()->set_automation_state (Off);
}
}
}
string
-PluginInsert::describe_parameter (Parameter param)
+PluginInsert::describe_parameter (Evoral::Parameter param)
{
if (param.type() != PluginAutomation)
return Automatable::describe_parameter(param);
}
}
-PluginInsert::PluginControl::PluginControl (PluginInsert
& p, boost::shared_ptr<AutomationList> list)
- : AutomationControl (p.session(), list, p.describe_parameter(list->parameter()))
+PluginInsert::PluginControl::PluginControl (PluginInsert
* p, const Evoral::Parameter ¶m, boost::shared_ptr<AutomationList> list)
+ : AutomationControl (p->session(), param, list, p->describe_parameter(param))
, _plugin (p)
- , _list (list)
{
Plugin::ParameterDescriptor desc;
- p.plugin(0)->get_parameter_descriptor (list->parameter().id(), desc);
+ p->plugin(0)->get_parameter_descriptor (param.id(), desc);
_logarithmic = desc.logarithmic;
_toggled = desc.toggled;
}
}
- for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugin._plugins.begin();
- i != _plugin._plugins.end(); ++i) {
+ for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugin->_plugins.begin();
+ i != _plugin->_plugins.end(); ++i) {
(*i)->set_parameter (_list->parameter().id(), val);
}
{
/* FIXME: probably should be taking out some lock here.. */
- float val = _plugin.get_parameter (_list->parameter());
+ float val = _plugin->get_parameter (_list->parameter());
return val;
projects / ardour.git / blobdiff