set<Evoral::Parameter> a = _plugins.front()->automatable ();
- ParameterDescriptor desc;
-
for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
if (i->type() == PluginAutomation) {
Evoral::Parameter param(*i);
+ ParameterDescriptor desc;
_plugins.front()->get_parameter_descriptor(i->id(), desc);
- /* the Parameter belonging to the actual plugin doesn't have its range set
- but we want the Controllable related to this Parameter to have those limits.
- */
-
- param.set_range (desc.lower, desc.upper, _plugins.front()->default_value(i->id()), desc.toggled);
can_automate (param);
- boost::shared_ptr<AutomationList> list(new AutomationList(param));
- add_control (boost::shared_ptr<AutomationControl> (new PluginControl(this, param, list)));
+ boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
+ add_control (boost::shared_ptr<AutomationControl> (new PluginControl(this, param, desc, list)));
+ } else if (i->type() == PluginPropertyAutomation) {
+ Evoral::Parameter param(*i);
+ const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
+ if (desc.datatype != Variant::NOTHING) {
+ boost::shared_ptr<AutomationList> list;
+ 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
= boost::dynamic_pointer_cast<AutomationControl>(li->second);
- if (c->parameter().type() == PluginAutomation && c->automation_playback()) {
+ if (c->list() && c->automation_playback()) {
bool valid;
const float val = c->list()->rt_safe_eval (now, valid);
if (_plugins.empty()) {
fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
<< endmsg;
- /*NOTREACHED*/
+ abort(); /*NOTREACHED*/
}
return _plugins[0]->default_value (param.id());
}
+
+bool
+PluginInsert::can_reset_all_parameters ()
+{
+ bool all = true;
+ uint32_t params = 0;
+ for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
+ bool ok=false;
+ const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
+
+ if (!ok || !_plugins[0]->parameter_is_input(cid)) {
+ continue;
+ }
+
+ boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
+ if (!ac) {
+ continue;
+ }
+
+ ++params;
+ if (ac->automation_state() & Play) {
+ all = false;
+ break;
+ }
+ }
+ return all && (params > 0);
+}
+
+bool
+PluginInsert::reset_parameters_to_default ()
+{
+ bool all = true;
+
+ for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
+ bool ok=false;
+ const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
+
+ if (!ok || !_plugins[0]->parameter_is_input(cid)) {
+ continue;
+ }
+
+ const float dflt = _plugins[0]->default_value (cid);
+ const float curr = _plugins[0]->get_parameter (cid);
+
+ if (dflt == curr) {
+ continue;
+ }
+
+ boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
+ if (!ac) {
+ continue;
+ }
+
+ if (ac->automation_state() & Play) {
+ all = false;
+ continue;
+ }
+
+ ac->set_value (dflt);
+ }
+ return all;
+}
+
boost::shared_ptr<Plugin>
PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
{
fatal << string_compose (_("programming error: %1"),
X_("unknown plugin type in PluginInsert::plugin_factory"))
<< endmsg;
- /*NOTREACHED*/
+ abort(); /*NOTREACHED*/
return boost::shared_ptr<Plugin> ((Plugin*) 0);
}
if ((*niter)->name() == plugin->state_node_name()) {
- plugin->set_state (**niter, version);
-
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
(*i)->set_state (**niter, version);
}
boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
- if (c) {
+ if (c && c->alist()) {
if (!child->children().empty()) {
c->alist()->set_state (*child->children().front(), version);
string
PluginInsert::describe_parameter (Evoral::Parameter param)
{
- if (param.type() != PluginAutomation) {
- return Automatable::describe_parameter(param);
+ if (param.type() == PluginAutomation) {
+ return _plugins[0]->describe_parameter (param);
+ } else if (param.type() == PluginPropertyAutomation) {
+ boost::shared_ptr<AutomationControl> c(automation_control(param));
+ if (c && !c->desc().label.empty()) {
+ return c->desc().label;
+ }
}
-
- return _plugins[0]->describe_parameter (param);
+ return Automatable::describe_parameter(param);
}
ARDOUR::framecnt_t
return plugin()->get_info()->type;
}
-PluginInsert::PluginControl::PluginControl (PluginInsert* p, const Evoral::Parameter ¶m, boost::shared_ptr<AutomationList> list)
- : AutomationControl (p->session(), param, list, p->describe_parameter(param))
+PluginInsert::PluginControl::PluginControl (PluginInsert* p,
+ const Evoral::Parameter& param,
+ const ParameterDescriptor& desc,
+ boost::shared_ptr<AutomationList> list)
+ : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
, _plugin (p)
{
- ParameterDescriptor desc;
- boost::shared_ptr<Plugin> plugin = p->plugin (0);
-
- alist()->reset_default (plugin->default_value (param.id()));
-
- plugin->get_parameter_descriptor (param.id(), desc);
- _logarithmic = desc.logarithmic;
- _sr_dependent = desc.sr_dependent;
- _toggled = desc.toggled;
+ if (alist()) {
+ alist()->reset_default (desc.normal);
+ if (desc.toggled) {
+ list->set_interpolation(Evoral::ControlList::Discrete);
+ }
+ }
if (desc.toggled) {
set_flags(Controllable::Toggle);
AutomationControl::set_value (user_val);
}
+XMLNode&
+PluginInsert::PluginControl::get_state ()
+{
+ stringstream ss;
+
+ XMLNode& node (AutomationControl::get_state());
+ ss << parameter().id();
+ node.add_property (X_("parameter"), ss.str());
+
+ return node;
+}
+
+/** @return `user' val */
double
-PluginInsert::PluginControl::internal_to_interface (double val) const
+PluginInsert::PluginControl::get_value () const
{
- val = Controllable::internal_to_interface(val);
-
- if (_logarithmic) {
- if (val > 0) {
- val = pow (val, 1/1.5);
- } else {
- val = 0;
- }
+ /* FIXME: probably should be taking out some lock here.. */
+ return _plugin->get_parameter (_list->parameter());
+}
+
+PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
+ const Evoral::Parameter& param,
+ const ParameterDescriptor& desc,
+ boost::shared_ptr<AutomationList> list)
+ : AutomationControl (p->session(), param, desc, list)
+ , _plugin (p)
+{
+ if (alist()) {
+ alist()->set_yrange (desc.lower, desc.upper);
+ alist()->reset_default (desc.normal);
}
- return val;
+ if (desc.toggled) {
+ set_flags(Controllable::Toggle);
+ }
}
-double
-PluginInsert::PluginControl::interface_to_internal (double val) const
+void
+PluginInsert::PluginPropertyControl::set_value (double user_val)
{
- if (_logarithmic) {
- if (val <= 0) {
- val= 0;
- } else {
- val = pow (val, 1.5);
- }
+ /* Old numeric set_value(), coerce to appropriate datatype if possible.
+ This is lossy, but better than nothing until Ardour's automation system
+ can handle various datatypes all the way down. */
+ const Variant value(_desc.datatype, user_val);
+ if (value.type() == Variant::NOTHING) {
+ error << "set_value(double) called for non-numeric property" << endmsg;
+ return;
}
- val = Controllable::interface_to_internal(val);
-
- return val;
+ for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
+ (*i)->set_property(_list->parameter().id(), value);
+ }
+
+ _value = value;
+ AutomationControl::set_value(user_val);
}
XMLNode&
-PluginInsert::PluginControl::get_state ()
+PluginInsert::PluginPropertyControl::get_state ()
{
stringstream ss;
XMLNode& node (AutomationControl::get_state());
ss << parameter().id();
- node.add_property (X_("parameter"), ss.str());
+ node.add_property (X_("property"), ss.str());
+ node.remove_property (X_("value"));
return node;
}
-/** @return `user' val */
double
-PluginInsert::PluginControl::get_value () const
+PluginInsert::PluginPropertyControl::get_value () const
{
- /* FIXME: probably should be taking out some lock here.. */
- return _plugin->get_parameter (_list->parameter());
+ return _value.to_double();
}
boost::shared_ptr<Plugin>
void
PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
{
- plugin->set_insert_info (this);
+ plugin->set_insert_id (this->id());
if (_plugins.empty()) {
/* first (and probably only) plugin instance - connect to relevant signals