X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fautomatable.cc;h=8629722889de2fe5d86a65140893146237addcbe;hb=aa0effb4cb38f4c3a06564bd9e6a0ee516d4f958;hp=2ce553a188668ff194ac7b33cb3df4c8a235545a;hpb=49ee64ada7f7661067a1dde8c02d40a8e2f6ca66;p=ardour.git diff --git a/libs/ardour/automatable.cc b/libs/ardour/automatable.cc index 2ce553a188..8629722889 100644 --- a/libs/ardour/automatable.cc +++ b/libs/ardour/automatable.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2001,2007 Paul Davis + Copyright (C) 2001,2007 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,15 +17,22 @@ */ -#include #include -#include #include #include -#include -#include -#include -#include + +#include + +#include "pbd/error.h" + +#include "ardour/amp.h" +#include "ardour/automatable.h" +#include "ardour/event_type_map.h" +#include "ardour/midi_track.h" +#include "ardour/pan_controllable.h" +#include "ardour/pannable.h" +#include "ardour/plugin_insert.h" +#include "ardour/session.h" #include "i18n.h" @@ -33,37 +40,45 @@ using namespace std; using namespace ARDOUR; using namespace PBD; +const string Automatable::xml_node_name = X_("Automation"); + +Automatable::Automatable(Session& session) + : _a_session(session) +{ +} + +Automatable::Automatable (const Automatable& other) + : ControlSet (other) + , _a_session (other._a_session) +{ + Glib::Threads::Mutex::Lock lm (other._control_lock); + + for (Controls::const_iterator i = other._controls.begin(); i != other._controls.end(); ++i) { + boost::shared_ptr ac (control_factory (i->first)); + add_control (ac); + } +} -Automatable::Automatable(Session& _session, const string& name) - : SessionObject(_session, name) - , _last_automation_snapshot(0) -{} +Automatable::~Automatable () +{ + { + Glib::Threads::Mutex::Lock lm (_control_lock); + + for (Controls::const_iterator li = _controls.begin(); li != _controls.end(); ++li) { + boost::dynamic_pointer_cast(li->second)->drop_references (); + } + } +} int Automatable::old_set_automation_state (const XMLNode& node) { const XMLProperty *prop; - + if ((prop = node.property ("path")) != 0) { load_automation (prop->value()); } else { - warning << string_compose(_("%1: Automation node has no path property"), _name) << endmsg; - } - - if ((prop = node.property ("visible")) != 0) { - uint32_t what; - stringstream sstr; - - _visible_parameter_automation.clear (); - - sstr << prop->value(); - while (1) { - sstr >> what; - if (sstr.fail()) { - break; - } - mark_automation_visible (what, true); - } + warning << _("Automation node has no path property") << endmsg; } return 0; @@ -74,22 +89,23 @@ Automatable::load_automation (const string& path) { string fullpath; - if (path[0] == '/') { // legacy + if (Glib::path_is_absolute (path)) { // legacy fullpath = path; } else { - fullpath = _session.automation_dir(); + fullpath = _a_session.automation_dir(); fullpath += path; } ifstream in (fullpath.c_str()); if (!in) { - warning << string_compose(_("%1: cannot open %2 to load automation data (%3)"), _name, fullpath, strerror (errno)) << endmsg; + warning << string_compose(_("cannot open %2 to load automation data (%3)") + , fullpath, strerror (errno)) << endmsg; return 1; } - Glib::Mutex::Lock lm (_automation_lock); - set tosave; - _parameter_automation.clear (); + Glib::Threads::Mutex::Lock lm (control_lock()); + set tosave; + controls().clear (); while (in) { double when; @@ -99,169 +115,359 @@ Automatable::load_automation (const string& path) in >> port; if (!in) break; in >> when; if (!in) goto bad; in >> value; if (!in) goto bad; - - AutomationList& al = automation_list (port); - al.add (when, value); - tosave.insert (port); + + Evoral::Parameter param(PluginAutomation, 0, port); + /* FIXME: this is legacy and only used for plugin inserts? I think? */ + boost::shared_ptr c = control (param, true); + c->list()->add (when, value); + tosave.insert (param); } - + return 0; bad: - error << string_compose(_("%1: cannot load automation data from %2"), _name, fullpath) << endmsg; - _parameter_automation.clear (); + error << string_compose(_("cannot load automation data from %2"), fullpath) << endmsg; + controls().clear (); return -1; } - void -Automatable::what_has_automation (set& s) const +Automatable::add_control(boost::shared_ptr ac) { - Glib::Mutex::Lock lm (_automation_lock); - map::const_iterator li; - - for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) { - s.insert ((*li).first); + Evoral::Parameter param = ac->parameter(); + + boost::shared_ptr al = boost::dynamic_pointer_cast (ac->list ()); + + if (al) { + al->automation_state_changed.connect_same_thread ( + _list_connections, + boost::bind (&Automatable::automation_list_automation_state_changed, + this, ac->parameter(), _1)); + } + + ControlSet::add_control (ac); + _can_automate_list.insert (param); + + if (al) { + automation_list_automation_state_changed (param, al->automation_state ()); // sync everything up } } -void -Automatable::what_has_visible_automation (set& s) const +string +Automatable::describe_parameter (Evoral::Parameter param) { - Glib::Mutex::Lock lm (_automation_lock); - set::const_iterator li; - - for (li = _visible_parameter_automation.begin(); li != _visible_parameter_automation.end(); ++li) { - s.insert (*li); + /* derived classes like PluginInsert should override this */ + + if (param == Evoral::Parameter(GainAutomation)) { + return _("Fader"); + } else if (param.type() == MuteAutomation) { + return _("Mute"); + } else if (param.type() == MidiCCAutomation) { + return string_compose("Controller %1 [%2]", param.id(), int(param.channel()) + 1); + } else if (param.type() == MidiPgmChangeAutomation) { + return string_compose("Program [%1]", int(param.channel()) + 1); + } else if (param.type() == MidiPitchBenderAutomation) { + return string_compose("Bender [%1]", int(param.channel()) + 1); + } else if (param.type() == MidiChannelPressureAutomation) { + return string_compose("Pressure [%1]", int(param.channel()) + 1); + } else { + return EventTypeMap::instance().to_symbol(param); } } -AutomationList& -Automatable::automation_list (uint32_t parameter) + +void +Automatable::can_automate (Evoral::Parameter what) +{ + _can_automate_list.insert (what); +} + +/** \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_xml_state (const XMLNode& node, Evoral::Parameter legacy_param) { - AutomationList* al = _parameter_automation[parameter]; + Glib::Threads::Mutex::Lock lm (control_lock()); + + /* Don't clear controls, since some may be special derived Controllable classes */ + + XMLNodeList nlist = node.children(); + XMLNodeIterator niter; + + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { + + /*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"); - 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); + Evoral::Parameter param = (id_prop + ? EventTypeMap::instance().new_parameter(id_prop->value()) + : legacy_param); + + if (param.type() == NullAutomation) { + warning << "Automation has null type" << endl; + continue; + } + + if (!id_prop) { + warning << "AutomationList node without automation-id property, " + << "using default: " << EventTypeMap::instance().to_symbol(legacy_param) << endmsg; + } + + boost::shared_ptr existing = automation_control (param); + + if (existing) { + existing->alist()->set_state (**niter, 3000); + } else { + boost::shared_ptr newcontrol = control_factory(param); + add_control (newcontrol); + boost::shared_ptr al (new AutomationList(**niter, param)); + newcontrol->set_list(al); + } + + } else { + error << "Expected AutomationList node, got '" << (*niter)->name() << "'" << endmsg; + } } - return *al; + return 0; } -string -Automatable::describe_parameter (uint32_t which) +XMLNode& +Automatable::get_automation_xml_state () { - /* derived classes will override this */ - return ""; + Glib::Threads::Mutex::Lock lm (control_lock()); + XMLNode* node = new XMLNode (Automatable::xml_node_name); + + if (controls().empty()) { + return *node; + } + + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr l = boost::dynamic_pointer_cast(li->second->list()); + if (!l->empty()) { + node->add_child_nocopy (l->get_state ()); + } + } + + return *node; } void -Automatable::can_automate (uint32_t what) +Automatable::set_parameter_automation_state (Evoral::Parameter param, AutoState s) { - _can_automate_list.insert (what); + Glib::Threads::Mutex::Lock lm (control_lock()); + + boost::shared_ptr c = automation_control (param, true); + + if (c && (s != c->automation_state())) { + c->set_automation_state (s); + _a_session.set_dirty (); + } } -void -Automatable::mark_automation_visible (uint32_t what, bool yn) +AutoState +Automatable::get_parameter_automation_state (Evoral::Parameter param) { - if (yn) { - _visible_parameter_automation.insert (what); - } else { - set::iterator i; + AutoState result = Off; - if ((i = _visible_parameter_automation.find (what)) != _visible_parameter_automation.end()) { - _visible_parameter_automation.erase (i); - } + boost::shared_ptr c = automation_control(param); + + if (c) { + result = c->automation_state(); } + + return result; } -bool -Automatable::find_next_event (nframes_t now, nframes_t end, ControlEvent& next_event) const +void +Automatable::set_parameter_automation_style (Evoral::Parameter param, AutoStyle s) { - map::const_iterator li; - AutomationList::TimeComparator cmp; + Glib::Threads::Mutex::Lock lm (control_lock()); - next_event.when = max_frames; - - for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) { - - AutomationList::const_iterator i; - const AutomationList& alist (*((*li).second)); - 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) { - if ((*i)->when > now) { - break; - } - } - - if (i != alist.const_end() && (*i)->when < end) { - - if ((*i)->when < next_event.when) { - next_event.when = (*i)->when; - } - } - } - - return next_event.when != max_frames; + boost::shared_ptr c = automation_control(param, true); + + if (c && (s != c->automation_style())) { + c->set_automation_style (s); + _a_session.set_dirty (); + } } -int -Automatable::set_automation_state (const XMLNode& node) -{ - Glib::Mutex::Lock lm (_automation_lock); +AutoStyle +Automatable::get_parameter_automation_style (Evoral::Parameter param) +{ + Glib::Threads::Mutex::Lock lm (control_lock()); - _parameter_automation.clear (); + boost::shared_ptr c = control(param); + boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); - XMLNodeList nlist = node.children(); - XMLNodeIterator niter; + if (c) { + return l->automation_style(); + } else { + return Absolute; // whatever + } +} - for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - uint32_t param; +void +Automatable::protect_automation () +{ + typedef set ParameterSet; + const ParameterSet& automated_params = what_can_be_automated (); + + for (ParameterSet::const_iterator i = automated_params.begin(); i != automated_params.end(); ++i) { + + boost::shared_ptr c = control(*i); + boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); + + switch (l->automation_state()) { + case Write: + l->set_automation_state (Off); + break; + case Touch: + l->set_automation_state (Play); + break; + default: + break; + } + } +} + +void +Automatable::transport_located (framepos_t now) +{ + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { - 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; + boost::shared_ptr c + = boost::dynamic_pointer_cast(li->second); + if (c) { + boost::shared_ptr l + = boost::dynamic_pointer_cast(c->list()); + + if (l) { + l->start_write_pass (now); + } } + } +} - AutomationList& al = automation_list (param); - if (al.set_state (*(*niter)->children().front())) { - goto bad; +void +Automatable::transport_stopped (framepos_t now) +{ + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + + boost::shared_ptr c + = boost::dynamic_pointer_cast(li->second); + if (c) { + boost::shared_ptr l + = boost::dynamic_pointer_cast(c->list()); + + if (l) { + /* Stop any active touch gesture just before we mark the write pass + as finished. If we don't do this, the transport can end up stopped with + an AutomationList thinking that a touch is still in progress and, + when the transport is re-started, a touch will magically + be happening without it ever have being started in the usual way. + */ + l->stop_touch (true, now); + l->write_pass_finished (now); + + if (l->automation_playback()) { + c->set_value(c->list()->eval(now)); + } + + if (l->automation_state() == Write) { + l->set_automation_state (Touch); + } + } + } + } +} + +boost::shared_ptr +Automatable::control_factory(const Evoral::Parameter& param) +{ + boost::shared_ptr list(new AutomationList(param)); + Evoral::Control* control = NULL; + if (param.type() >= MidiCCAutomation && param.type() <= MidiChannelPressureAutomation) { + MidiTrack* mt = dynamic_cast(this); + if (mt) { + control = new MidiTrack::MidiControl(mt, param); + list.reset(); // No list, this is region "automation" + } else { + warning << "MidiCCAutomation for non-MidiTrack" << endl; + } + } else if (param.type() == PluginAutomation) { + PluginInsert* pi = dynamic_cast(this); + if (pi) { + control = new PluginInsert::PluginControl(pi, param); + } else { + warning << "PluginAutomation for non-Plugin" << endl; + } + } else if (param.type() == GainAutomation) { + Amp* amp = dynamic_cast(this); + if (amp) { + control = new Amp::GainControl(X_("gaincontrol"), _a_session, amp, param); + } else { + warning << "GainAutomation for non-Amp" << endl; + } + } else if (param.type() == PanAzimuthAutomation || param.type() == PanWidthAutomation || param.type() == PanElevationAutomation) { + Pannable* pannable = dynamic_cast(this); + if (pannable) { + control = new PanControllable (_a_session, pannable->describe_parameter (param), pannable, param); + } else { + warning << "PanAutomation for non-Pannable" << endl; } } - return 0; + if (!control) { + control = new AutomationControl(_a_session, param); + } - bad: - error << string_compose(_("%1: cannot load automation data from XML"), _name) << endmsg; - _parameter_automation.clear (); - return -1; + control->set_list(list); + return boost::shared_ptr(control); } -XMLNode& -Automatable::get_automation_state () +boost::shared_ptr +Automatable::automation_control (const Evoral::Parameter& id, bool create) { - Glib::Mutex::Lock lm (_automation_lock); - XMLNode* node = new XMLNode (X_("Automation")); - string fullpath; + return boost::dynamic_pointer_cast(Evoral::ControlSet::control(id, create)); +} - if (_parameter_automation.empty()) { - return *node; - } +boost::shared_ptr +Automatable::automation_control (const Evoral::Parameter& id) const +{ + return boost::dynamic_pointer_cast(Evoral::ControlSet::control(id)); +} - map::iterator li; - - for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) { - - XMLNode* child; - - 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 ()); +void +Automatable::clear_controls () +{ + _control_connections.drop_connections (); + ControlSet::clear_controls (); +} + +string +Automatable::value_as_string (boost::shared_ptr ac) const +{ + std::stringstream s; + + /* this is a the default fallback for this virtual method. Derived Automatables + are free to override this to display the values of their parameters/controls + in different ways. + */ + + // Hack to display CC as integer value, rather than double + if (ac->parameter().type() == MidiCCAutomation) { + s << lrint (ac->get_value()); + } else { + s << std::fixed << std::setprecision(3) << ac->get_value(); } - return *node; + return s.str (); }