X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fautomatable.cc;h=84f8cd56cca540948a29b93998d29a72e5d3fb29;hb=07112b55e0bb7ceb9e5c05ab4df167ecaf7edd9b;hp=903ae5df75587baef6380ad9dbbebe379368cd4b;hpb=9b7a35cdc0d63d05d91f9deba294bcb7113a9106;p=ardour.git diff --git a/libs/ardour/automatable.cc b/libs/ardour/automatable.cc index 903ae5df75..84f8cd56cc 100644 --- a/libs/ardour/automatable.cc +++ b/libs/ardour/automatable.cc @@ -17,25 +17,20 @@ */ -#include "ardour/ardour.h" #include -#include #include #include #include #include "pbd/error.h" -#include "pbd/enumwriter.h" -#include "pbd/stacktrace.h" -#include "midi++/names.h" - -#include "ardour/automatable.h" #include "ardour/amp.h" +#include "ardour/automatable.h" #include "ardour/event_type_map.h" #include "ardour/midi_track.h" -#include "ardour/panner.h" +#include "ardour/pan_controllable.h" +#include "ardour/pannable.h" #include "ardour/plugin_insert.h" #include "ardour/session.h" @@ -45,26 +40,36 @@ using namespace std; using namespace ARDOUR; using namespace PBD; -nframes_t Automatable::_automation_interval = 0; +const string Automatable::xml_node_name = X_("Automation"); Automatable::Automatable(Session& session) : _a_session(session) - , _last_automation_snapshot(0) { } Automatable::Automatable (const Automatable& other) : ControlSet (other) , _a_session (other._a_session) - , _last_automation_snapshot (0) { - Glib::Mutex::Lock lm (other._control_lock); + 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 () +{ + { + 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) { @@ -76,24 +81,6 @@ Automatable::old_set_automation_state (const XMLNode& node) warning << _("Automation node has no path property") << endmsg; } - if ((prop = node.property ("visible")) != 0) { - uint32_t what; - stringstream sstr; - - _visible_controls.clear (); - - sstr << prop->value(); - while (1) { - sstr >> what; - if (sstr.fail()) { - break; - } - mark_automation_visible (Evoral::Parameter(PluginAutomation, 0, what), true); - } - } - - _last_automation_snapshot = 0; - return 0; } @@ -116,12 +103,10 @@ Automatable::load_automation (const string& path) return 1; } - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); set tosave; controls().clear (); - _last_automation_snapshot = 0; - while (in) { double when; double value; @@ -153,7 +138,7 @@ Automatable::add_control(boost::shared_ptr ac) boost::shared_ptr al = boost::dynamic_pointer_cast (ac->list ()); assert (al); - + al->automation_state_changed.connect_same_thread ( _list_connections, boost::bind (&Automatable::automation_list_automation_state_changed, this, ac->parameter(), _1) ); @@ -164,17 +149,6 @@ Automatable::add_control(boost::shared_ptr ac) automation_list_automation_state_changed (param, al->automation_state ()); // sync everything up } -void -Automatable::what_has_visible_data(set& s) const -{ - Glib::Mutex::Lock lm (control_lock()); - set::const_iterator li; - - for (li = _visible_controls.begin(); li != _visible_controls.end(); ++li) { - s.insert (*li); - } -} - string Automatable::describe_parameter (Evoral::Parameter param) { @@ -182,12 +156,8 @@ Automatable::describe_parameter (Evoral::Parameter param) if (param == Evoral::Parameter(GainAutomation)) { return _("Fader"); - } else if (param.type() == PanAutomation) { - /* ID's are zero-based, present them as 1-based */ - return (string_compose(_("Pan %1"), param.id() + 1)); } else if (param.type() == MidiCCAutomation) { - return string_compose("%1: %2 [%3]", - param.id() + 1, midi_name(param.id()), int(param.channel()) + 1); + 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) { @@ -205,20 +175,6 @@ Automatable::can_automate (Evoral::Parameter what) _can_automate_list.insert (what); } -void -Automatable::mark_automation_visible (Evoral::Parameter what, bool yn) -{ - if (yn) { - _visible_controls.insert (what); - } else { - set::iterator i; - - if ((i = _visible_controls.find (what)) != _visible_controls.end()) { - _visible_controls.erase (i); - } - } -} - /** \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. @@ -226,12 +182,10 @@ Automatable::mark_automation_visible (Evoral::Parameter what, bool yn) int Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter legacy_param) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); /* Don't clear controls, since some may be special derived Controllable classes */ - _visible_controls.clear (); - XMLNodeList nlist = node.children(); XMLNodeIterator niter; @@ -255,19 +209,19 @@ Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter le continue; } - boost::shared_ptr al (new AutomationList(**niter, param)); - if (!id_prop) { warning << "AutomationList node without automation-id property, " << "using default: " << EventTypeMap::instance().to_symbol(legacy_param) << endmsg; } - boost::shared_ptr existing = control(param); + boost::shared_ptr existing = automation_control (param); + if (existing) { - existing->set_list(al); + existing->alist()->set_state (**niter, 3000); } else { - boost::shared_ptr newcontrol = control_factory(param); - add_control(newcontrol); + boost::shared_ptr newcontrol = control_factory(param); + add_control (newcontrol); + boost::shared_ptr al (new AutomationList(**niter, param)); newcontrol->set_list(al); } @@ -276,24 +230,21 @@ Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter le } } - _last_automation_snapshot = 0; - return 0; } XMLNode& Automatable::get_automation_xml_state () { - Glib::Mutex::Lock lm (control_lock()); - XMLNode* node = new XMLNode (X_("Automation")); + 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()); + boost::shared_ptr l = boost::dynamic_pointer_cast(li->second->list()); if (!l->empty()) { node->add_child_nocopy (l->get_state ()); } @@ -305,13 +256,12 @@ Automatable::get_automation_xml_state () void Automatable::set_parameter_automation_state (Evoral::Parameter param, AutoState s) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); - boost::shared_ptr c = control (param, true); - boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); + boost::shared_ptr c = automation_control (param, true); - if (s != l->automation_state()) { - l->set_automation_state (s); + if (c && (s != c->automation_state())) { + c->set_automation_state (s); _a_session.set_dirty (); } } @@ -321,11 +271,10 @@ Automatable::get_parameter_automation_state (Evoral::Parameter param) { AutoState result = Off; - boost::shared_ptr c = control(param); - boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); - + boost::shared_ptr c = automation_control(param); + if (c) { - result = l->automation_state(); + result = c->automation_state(); } return result; @@ -334,13 +283,12 @@ Automatable::get_parameter_automation_state (Evoral::Parameter param) void Automatable::set_parameter_automation_style (Evoral::Parameter param, AutoStyle s) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); - boost::shared_ptr c = control(param, true); - boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); + boost::shared_ptr c = automation_control(param, true); - if (s != l->automation_style()) { - l->set_automation_style (s); + if (c && (s != c->automation_style())) { + c->set_automation_style (s); _a_session.set_dirty (); } } @@ -348,7 +296,7 @@ Automatable::set_parameter_automation_style (Evoral::Parameter param, AutoStyle AutoStyle Automatable::get_parameter_automation_style (Evoral::Parameter param) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); boost::shared_ptr c = control(param); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); @@ -364,11 +312,9 @@ void Automatable::protect_automation () { typedef set ParameterSet; - ParameterSet automated_params; - - what_has_data(automated_params); + const ParameterSet& automated_params = what_can_be_automated (); - for (ParameterSet::iterator i = automated_params.begin(); i != automated_params.end(); ++i) { + 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()); @@ -387,19 +333,20 @@ Automatable::protect_automation () } void -Automatable::automation_snapshot (nframes_t now, bool force) +Automatable::transport_located (framepos_t now) { - if (force || _last_automation_snapshot > now || (now - _last_automation_snapshot) > _automation_interval) { + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { - for (Controls::iterator i = controls().begin(); i != controls().end(); ++i) { - boost::shared_ptr c - = boost::dynamic_pointer_cast(i->second); - if (_a_session.transport_rolling() && c->automation_write()) { - c->list()->rt_add (now, i->second->user_double()); + 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); } } - - _last_automation_snapshot = now; } } @@ -413,14 +360,21 @@ Automatable::transport_stopped (framepos_t now) 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); } @@ -455,13 +409,12 @@ Automatable::control_factory(const Evoral::Parameter& param) } else { warning << "GainAutomation for non-Amp" << endl; } - } else if (param.type() == PanAutomation) { - Panner* panner = dynamic_cast(this); - if (panner) { - StreamPanner& sp (panner->streampanner (param.channel())); - control = new StreamPanner::PanControllable (_a_session, X_("direction"), sp, param); + } 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-Panner" << endl; + warning << "PanAutomation for non-Pannable" << endl; } } @@ -491,3 +444,23 @@ 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 s.str (); +}