X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fautomatable.cc;h=45b19d1997aea345f44bbba2bdbc9975f06e478b;hb=1059b3f48e568b60d5e248d94fbb9110a2dd1a16;hp=2ce553a188668ff194ac7b33cb3df4c8a235545a;hpb=49ee64ada7f7661067a1dde8c02d40a8e2f6ca66;p=ardour.git diff --git a/libs/ardour/automatable.cc b/libs/ardour/automatable.cc index 2ce553a188..45b19d1997 100644 --- a/libs/ardour/automatable.cc +++ b/libs/ardour/automatable.cc @@ -26,6 +26,7 @@ #include #include #include +#include #include "i18n.h" @@ -33,6 +34,7 @@ using namespace std; using namespace ARDOUR; using namespace PBD; +nframes_t Automatable::_automation_interval = 0; Automatable::Automatable(Session& _session, const string& name) : SessionObject(_session, name) @@ -54,7 +56,7 @@ Automatable::old_set_automation_state (const XMLNode& node) uint32_t what; stringstream sstr; - _visible_parameter_automation.clear (); + _visible_controls.clear (); sstr << prop->value(); while (1) { @@ -62,9 +64,11 @@ Automatable::old_set_automation_state (const XMLNode& node) if (sstr.fail()) { break; } - mark_automation_visible (what, true); + mark_automation_visible (Parameter(PluginAutomation, what), true); } } + + _last_automation_snapshot = 0; return 0; } @@ -88,8 +92,10 @@ Automatable::load_automation (const string& path) } Glib::Mutex::Lock lm (_automation_lock); - set tosave; - _parameter_automation.clear (); + set tosave; + _controls.clear (); + + _last_automation_snapshot = 0; while (in) { double when; @@ -100,78 +106,124 @@ Automatable::load_automation (const string& path) in >> when; if (!in) goto bad; in >> value; if (!in) goto bad; - AutomationList& al = automation_list (port); - al.add (when, value); - tosave.insert (port); + /* FIXME: this is legacy and only used for plugin inserts? I think? */ + boost::shared_ptr c = control (Parameter(PluginAutomation, port), true); + c->list()->add (when, value); + tosave.insert (Parameter(PluginAutomation, port)); } return 0; bad: error << string_compose(_("%1: cannot load automation data from %2"), _name, fullpath) << endmsg; - _parameter_automation.clear (); + _controls.clear (); return -1; } +void +Automatable::add_control(boost::shared_ptr ac) +{ + Parameter param = ac->parameter(); + + _controls[param] = ac; + + _can_automate_list.insert(param); + + // Sync everything (derived classes) up to initial values + auto_state_changed(param); +} void -Automatable::what_has_automation (set& s) const +Automatable::what_has_automation (set& s) const { Glib::Mutex::Lock lm (_automation_lock); - map::const_iterator li; + Controls::const_iterator li; - for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) { + // FIXME: correct semantics? + for (li = _controls.begin(); li != _controls.end(); ++li) { s.insert ((*li).first); } } void -Automatable::what_has_visible_automation (set& s) const +Automatable::what_has_visible_automation (set& s) const { Glib::Mutex::Lock lm (_automation_lock); - set::const_iterator li; + set::const_iterator li; - for (li = _visible_parameter_automation.begin(); li != _visible_parameter_automation.end(); ++li) { + for (li = _visible_controls.begin(); li != _visible_controls.end(); ++li) { s.insert (*li); } } -AutomationList& -Automatable::automation_list (uint32_t parameter) + +/** Returns NULL if we don't have an AutomationList for \a parameter. + */ +boost::shared_ptr +Automatable::control (Parameter parameter, bool create_if_missing) { - AutomationList* al = _parameter_automation[parameter]; + Controls::iterator i = _controls.find(parameter); + + if (i != _controls.end()) { + return i->second; + + } else if (create_if_missing) { + boost::shared_ptr al (new AutomationList ( + parameter, FLT_MIN, FLT_MAX, default_parameter_value (parameter))); + boost::shared_ptr ac(control_factory(al)); + add_control(ac); + return ac; - if (al == 0) { - al = _parameter_automation[parameter] = new AutomationList (default_parameter_value (parameter)); - /* let derived classes do whatever they need with this */ - automation_list_creation_callback (parameter, *al); + } else { + //warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg; + return boost::shared_ptr(); } +} - return *al; +boost::shared_ptr +Automatable::control (Parameter parameter) const +{ + Controls::const_iterator i = _controls.find(parameter); + + if (i != _controls.end()) { + return i->second; + } else { + //warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg; + return boost::shared_ptr(); + } } + string -Automatable::describe_parameter (uint32_t which) +Automatable::describe_parameter (Parameter param) { - /* derived classes will override this */ - return ""; + /* derived classes like PluginInsert should override this */ + + if (param == Parameter(GainAutomation)) + return _("Fader"); + else if (param.type() == PanAutomation) + return (string_compose(_("Pan %1"), param.id())); + else if (param.type() == MidiCCAutomation) + return string_compose("CC %1", param.id()); + else + return param.to_string(); } void -Automatable::can_automate (uint32_t what) +Automatable::can_automate (Parameter what) { _can_automate_list.insert (what); } void -Automatable::mark_automation_visible (uint32_t what, bool yn) +Automatable::mark_automation_visible (Parameter what, bool yn) { if (yn) { - _visible_parameter_automation.insert (what); + _visible_controls.insert (what); } else { - set::iterator i; + set::iterator i; - if ((i = _visible_parameter_automation.find (what)) != _visible_parameter_automation.end()) { - _visible_parameter_automation.erase (i); + if ((i = _visible_controls.find (what)) != _visible_controls.end()) { + _visible_controls.erase (i); } } } @@ -179,24 +231,24 @@ Automatable::mark_automation_visible (uint32_t what, bool yn) bool Automatable::find_next_event (nframes_t now, nframes_t end, ControlEvent& next_event) const { - map::const_iterator li; - AutomationList::TimeComparator cmp; + Controls::const_iterator li; next_event.when = max_frames; - for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) { + for (li = _controls.begin(); li != _controls.end(); ++li) { AutomationList::const_iterator i; - const AutomationList& alist (*((*li).second)); + boost::shared_ptr alist (li->second->list()); ControlEvent cp (now, 0.0f); - for (i = lower_bound (alist.const_begin(), alist.const_end(), &cp, cmp); i != alist.const_end() && (*i)->when < end; ++i) { + for (i = lower_bound (alist->const_begin(), alist->const_end(), &cp, AutomationList::time_comparator); + i != alist->const_end() && (*i)->when < end; ++i) { if ((*i)->when > now) { break; } } - if (i != alist.const_end() && (*i)->when < end) { + if (i != alist->const_end() && (*i)->when < end) { if ((*i)->when < next_event.when) { next_event.when = (*i)->when; @@ -207,36 +259,57 @@ Automatable::find_next_event (nframes_t now, nframes_t end, ControlEvent& next_e return next_event.when != max_frames; } +/** \a legacy_param is used for loading legacy sessions where an object (IO, Panner) + * had a single automation parameter, with it's type implicit. Derived objects should + * pass that type and it will be used for the untyped AutomationList found. + */ int -Automatable::set_automation_state (const XMLNode& node) +Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param) { Glib::Mutex::Lock lm (_automation_lock); - _parameter_automation.clear (); + /* Don't clear controls, since some may be special derived Controllable classes */ + + _visible_controls.clear (); XMLNodeList nlist = node.children(); XMLNodeIterator niter; - + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - uint32_t param; - if (sscanf ((*niter)->name().c_str(), "parameter-%" PRIu32, ¶m) != 1) { - error << string_compose (_("%2: badly formatted node name in XML automation state, ignored"), _name) << endmsg; - continue; - } + /*if (sscanf ((*niter)->name().c_str(), "parameter-%" PRIu32, ¶m) != 1) { + error << string_compose (_("%2: badly formatted node name in XML automation state, ignored"), _name) << endmsg; + continue; + }*/ + + if ((*niter)->name() == "AutomationList") { + + const XMLProperty* id_prop = (*niter)->property("automation-id"); + + Parameter param = (id_prop ? Parameter(id_prop->value()) : legacy_param); + + boost::shared_ptr al (new AutomationList(**niter, param)); + + if (!id_prop) { + warning << "AutomationList node without automation-id property, " + << "using default: " << legacy_param.to_string() << endmsg; + al->set_parameter(legacy_param); + } + + boost::shared_ptr existing = control(param); + if (existing) + existing->set_list(al); + else + add_control(control_factory(al)); - AutomationList& al = automation_list (param); - if (al.set_state (*(*niter)->children().front())) { - goto bad; + } else { + error << "Expected AutomationList node, got '" << (*niter)->name() << endmsg; } } - return 0; + _last_automation_snapshot = 0; - bad: - error << string_compose(_("%1: cannot load automation data from XML"), _name) << endmsg; - _parameter_automation.clear (); - return -1; + return 0; } XMLNode& @@ -244,24 +317,149 @@ Automatable::get_automation_state () { Glib::Mutex::Lock lm (_automation_lock); XMLNode* node = new XMLNode (X_("Automation")); - string fullpath; - - if (_parameter_automation.empty()) { + + if (_controls.empty()) { return *node; } - map::iterator li; + for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) { + node->add_child_nocopy (li->second->list()->get_state ()); + } + + return *node; +} + +void +Automatable::clear_automation () +{ + Glib::Mutex::Lock lm (_automation_lock); + + for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) + li->second->list()->clear(); +} - for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) { +void +Automatable::set_parameter_automation_state (Parameter param, AutoState s) +{ + Glib::Mutex::Lock lm (_automation_lock); - XMLNode* child; + boost::shared_ptr c = control (param, true); + + if (s != c->list()->automation_state()) { + c->list()->set_automation_state (s); + _session.set_dirty (); + } +} + +AutoState +Automatable::get_parameter_automation_state (Parameter param, bool lock) +{ + AutoState result = Off; + + if (lock) + _automation_lock.lock(); + + boost::shared_ptr c = control(param); + + if (c) + result = c->list()->automation_state(); + + if (lock) + _automation_lock.unlock(); + + return result; +} + +void +Automatable::set_parameter_automation_style (Parameter param, AutoStyle s) +{ + Glib::Mutex::Lock lm (_automation_lock); + + boost::shared_ptr c = control(param, true); + + if (s != c->list()->automation_style()) { + c->list()->set_automation_style (s); + _session.set_dirty (); + } +} + +AutoStyle +Automatable::get_parameter_automation_style (Parameter param) +{ + Glib::Mutex::Lock lm (_automation_lock); + + boost::shared_ptr c = control(param); + + if (c) { + return c->list()->automation_style(); + } else { + return Absolute; // whatever + } +} + +void +Automatable::protect_automation () +{ + set automated_params; + + what_has_automation (automated_params); + + for (set::iterator i = automated_params.begin(); i != automated_params.end(); ++i) { + + boost::shared_ptr c = control(*i); + + switch (c->list()->automation_state()) { + case Write: + c->list()->set_automation_state (Off); + break; + case Touch: + c->list()->set_automation_state (Play); + break; + default: + break; + } + } +} + +void +Automatable::automation_snapshot (nframes_t now) +{ + if (_last_automation_snapshot > now || (now - _last_automation_snapshot) > _automation_interval) { + + for (Controls::iterator i = _controls.begin(); i != _controls.end(); ++i) { + if (i->second->list()->automation_write()) { + i->second->list()->rt_add (now, i->second->user_value()); + } + } - char buf[64]; - stringstream str; - snprintf (buf, sizeof (buf), "parameter-%" PRIu32, li->first); - child = new XMLNode (buf); - child->add_child_nocopy (li->second->get_state ()); + _last_automation_snapshot = now; } +} - return *node; +void +Automatable::transport_stopped (nframes_t now) +{ + for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) { + + boost::shared_ptr c = li->second; + + c->list()->reposition_for_rt_add (now); + + if (c->list()->automation_state() != Off) { + c->set_value(c->list()->eval(now)); + } + } } + +/* FIXME: this probably doesn't belong here */ +boost::shared_ptr +Automatable::control_factory(boost::shared_ptr list) +{ + if (list->parameter().type() == MidiCCAutomation) { + // FIXME: this will die horribly if this is not a MidiTrack + return boost::shared_ptr(new MidiTrack::MidiControl((MidiTrack*)this, list)); + } else { + return boost::shared_ptr(new AutomationControl(_session, list)); + } +} +