X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fautomatable.cc;h=3230dac28f28fd40200765a6aad808c412f062b3;hb=84272b4e27e537bf2c38c9cd25675c61addea40a;hp=3c5d610ce88eaf7f1b4ffccfca4d8846741c18fd;hpb=55094b723774086d0f54d688b1ca73a4df82b93e;p=ardour.git diff --git a/libs/ardour/automatable.cc b/libs/ardour/automatable.cc index 3c5d610ce8..3230dac28f 100644 --- a/libs/ardour/automatable.cc +++ b/libs/ardour/automatable.cc @@ -29,55 +29,69 @@ #include "ardour/automatable.h" #include "ardour/event_type_map.h" #include "ardour/gain_control.h" +#include "ardour/monitor_control.h" #include "ardour/midi_track.h" #include "ardour/pan_controllable.h" #include "ardour/pannable.h" #include "ardour/plugin.h" #include "ardour/plugin_insert.h" +#include "ardour/record_enable_control.h" #include "ardour/session.h" +#ifdef LV2_SUPPORT #include "ardour/uri_map.h" +#endif #include "ardour/value_as_string.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; using namespace PBD; +/* used for templates (previously: !full_state) */ +bool Automatable::skip_saving_automation = false; + const string Automatable::xml_node_name = X_("Automation"); Automatable::Automatable(Session& session) : _a_session(session) + , _automated_controls (new ControlList) { } Automatable::Automatable (const Automatable& other) - : ControlSet (other) - , _a_session (other._a_session) + : ControlSet (other) + , Slavable () + , _a_session (other._a_session) + , _automated_controls (new ControlList) { - Glib::Threads::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)); + 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); + RCUWriter writer (_automated_controls); + boost::shared_ptr cl = writer.get_copy (); + cl->clear (); + } + _automated_controls.flush (); - for (Controls::const_iterator li = _controls.begin(); li != _controls.end(); ++li) { - boost::dynamic_pointer_cast(li->second)->drop_references (); - } + 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; + XMLProperty const * prop; if ((prop = node.property ("path")) != 0) { load_automation (prop->value()); @@ -134,7 +148,7 @@ Automatable::load_automation (const string& path) return 0; - bad: +bad: error << string_compose(_("cannot load automation data from %2"), fullpath) << endmsg; controls().clear (); ::fclose (in); @@ -148,7 +162,9 @@ Automatable::add_control(boost::shared_ptr ac) boost::shared_ptr al = boost::dynamic_pointer_cast (ac->list ()); - if (al) { + boost::shared_ptr actl (boost::dynamic_pointer_cast (ac)); + + if ((!actl || !(actl->flags() & Controllable::NotAutomatable)) && al) { al->automation_state_changed.connect_same_thread ( _list_connections, boost::bind (&Automatable::automation_list_automation_state_changed, @@ -157,7 +173,7 @@ Automatable::add_control(boost::shared_ptr ac) ControlSet::add_control (ac); - if (al) { + if ((!actl || !(actl->flags() & Controllable::NotAutomatable)) && al) { _can_automate_list.insert (param); automation_list_automation_state_changed (param, al->automation_state ()); // sync everything up } @@ -182,6 +198,8 @@ Automatable::describe_parameter (Evoral::Parameter param) return string_compose("Bender [%1]", int(param.channel()) + 1); } else if (param.type() == MidiChannelPressureAutomation) { return string_compose("Pressure [%1]", int(param.channel()) + 1); + } else if (param.type() == MidiNotePressureAutomation) { + return string_compose("PolyPressure [%1]", int(param.channel()) + 1); #ifdef LV2_SUPPORT } else if (param.type() == PluginPropertyAutomation) { return string_compose("Property %1", URIMap::instance().id_to_uri(param.id())); @@ -220,7 +238,7 @@ Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter le if ((*niter)->name() == "AutomationList") { - const XMLProperty* id_prop = (*niter)->property("automation-id"); + XMLProperty const * id_prop = (*niter)->property("automation-id"); Evoral::Parameter param = (id_prop ? EventTypeMap::instance().from_symbol(id_prop->value()) @@ -229,21 +247,34 @@ Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter le 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; } + if (_can_automate_list.find (param) == _can_automate_list.end ()) { + boost::shared_ptr actl = automation_control (param); + if (actl && (*niter)->children().size() > 0 && Config->get_limit_n_automatables () > 0) { + actl->set_flags (Controllable::Flag ((int)actl->flags() & ~Controllable::NotAutomatable)); + can_automate (param); + info << "Marked parmater as automatable" << endl; + } else { + warning << "Ignored automation data for non-automatable parameter" << endl; + continue; + } + } + + boost::shared_ptr existing = automation_control (param); if (existing) { - existing->alist()->set_state (**niter, 3000); + existing->alist()->set_state (**niter, 3000); } else { - boost::shared_ptr newcontrol = control_factory(param); + boost::shared_ptr newcontrol = control_factory(param); add_control (newcontrol); - boost::shared_ptr al (new AutomationList(**niter, param)); + boost::shared_ptr al (new AutomationList(**niter, param)); newcontrol->set_list(al); } @@ -267,7 +298,7 @@ Automatable::get_automation_xml_state () for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { boost::shared_ptr l = boost::dynamic_pointer_cast(li->second->list()); - if (l && !l->empty()) { + if (l) { node->add_child_nocopy (l->get_state ()); } } @@ -303,34 +334,6 @@ Automatable::get_parameter_automation_state (Evoral::Parameter param) return result; } -void -Automatable::set_parameter_automation_style (Evoral::Parameter param, AutoStyle s) -{ - Glib::Threads::Mutex::Lock lm (control_lock()); - - boost::shared_ptr c = automation_control(param, true); - - if (c && (s != c->automation_style())) { - c->set_automation_style (s); - _a_session.set_dirty (); - } -} - -AutoStyle -Automatable::get_parameter_automation_style (Evoral::Parameter param) -{ - Glib::Threads::Mutex::Lock lm (control_lock()); - - boost::shared_ptr c = control(param); - boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); - - if (c) { - return l->automation_style(); - } else { - return Absolute; // whatever - } -} - void Automatable::protect_automation () { @@ -346,6 +349,8 @@ Automatable::protect_automation () case Write: l->set_automation_state (Off); break; + case Latch: + /* fall through */ case Touch: l->set_automation_state (Play); break; @@ -356,25 +361,53 @@ Automatable::protect_automation () } void -Automatable::transport_located (framepos_t now) +Automatable::non_realtime_locate (samplepos_t now) { + bool rolling = _a_session.transport_rolling (); + 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::shared_ptr l = boost::dynamic_pointer_cast(c->list()); - if (l) { - l->start_write_pass (now); + if (!l) { + continue; + } + + bool am_touching = c->touching (); + if (rolling && am_touching) { + /* when locating while rolling, and writing automation, + * start a new write pass. + * compare to compare to non_realtime_transport_stop() + */ + const bool list_did_write = !l->in_new_write_pass (); + c->stop_touch (-1); // time is irrelevant + l->stop_touch (-1); + c->commit_transaction (list_did_write); + l->write_pass_finished (now, Config->get_automation_thinning_factor ()); + + if (l->automation_state () == Write) { + l->set_automation_state (Touch); + } + if (l->automation_playback ()) { + c->set_value_unchecked (c->list ()->eval (now)); + } + } + + l->start_write_pass (now); + + if (rolling && am_touching) { + c->start_touch (now); } } } } void -Automatable::transport_stopped (framepos_t now) +Automatable::non_realtime_transport_stop (samplepos_t now, bool /*flush_processors*/) { for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { boost::shared_ptr c = @@ -397,7 +430,8 @@ Automatable::transport_stopped (framepos_t now) */ const bool list_did_write = !l->in_new_write_pass (); - l->stop_touch (true, now); + c->stop_touch (now); + l->stop_touch (now); c->commit_transaction (list_did_write); @@ -413,6 +447,56 @@ Automatable::transport_stopped (framepos_t now) } } +void +Automatable::automation_run (samplepos_t start, pframes_t nframes, bool only_active) +{ + if (only_active) { + boost::shared_ptr cl = _automated_controls.reader (); + for (ControlList::const_iterator ci = cl->begin(); ci != cl->end(); ++ci) { + (*ci)->automation_run (start, nframes); + } + return; + } + + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr c = + boost::dynamic_pointer_cast(li->second); + if (!c) { + continue; + } + c->automation_run (start, nframes); + } +} + +void +Automatable::automation_list_automation_state_changed (Evoral::Parameter param, AutoState as) +{ + { + boost::shared_ptr c (automation_control(param)); + assert (c && c->list()); + + RCUWriter writer (_automated_controls); + boost::shared_ptr cl = writer.get_copy (); + + ControlList::iterator fi = std::find (cl->begin(), cl->end(), c); + if (fi != cl->end()) { + cl->erase (fi); + } + switch (as) { + /* all potential automation_playback() states */ + case Play: + case Touch: + case Latch: + cl->push_back (c); + break; + case Off: + case Write: + break; + } + } + _automated_controls.flush(); +} + boost::shared_ptr Automatable::control_factory(const Evoral::Parameter& param) { @@ -420,6 +504,7 @@ Automatable::control_factory(const Evoral::Parameter& param) bool make_list = true; ParameterDescriptor desc(param); boost::shared_ptr list; + if (param.type() >= MidiCCAutomation && param.type() <= MidiChannelPressureAutomation) { MidiTrack* mt = dynamic_cast(this); if (mt) { @@ -460,6 +545,27 @@ Automatable::control_factory(const Evoral::Parameter& param) } else { warning << "PanAutomation for non-Pannable" << endl; } + } else if (param.type() == RecEnableAutomation) { + Recordable* re = dynamic_cast (this); + if (re) { + control = new RecordEnableControl (_a_session, X_("recenable"), *re); + } + } else if (param.type() == MonitoringAutomation) { + Monitorable* m = dynamic_cast(this); + if (m) { + control = new MonitorControl (_a_session, X_("monitor"), *m); + } + } else if (param.type() == SoloAutomation) { + Soloable* s = dynamic_cast(this); + Muteable* m = dynamic_cast(this); + if (s && m) { + control = new SoloControl (_a_session, X_("solo"), *s, *m); + } + } else if (param.type() == MuteAutomation) { + Muteable* m = dynamic_cast(this); + if (m) { + control = new MuteControl (_a_session, X_("mute"), *m); + } } if (make_list && !list) { @@ -473,6 +579,21 @@ Automatable::control_factory(const Evoral::Parameter& param) return boost::shared_ptr(control); } +boost::shared_ptr +Automatable::automation_control (PBD::ID const & id) const +{ + Controls::const_iterator li; + + for (li = _controls.begin(); li != _controls.end(); ++li) { + boost::shared_ptr ac = boost::dynamic_pointer_cast (li->second); + if (ac && (ac->id() == id)) { + return ac; + } + } + + return boost::shared_ptr(); +} + boost::shared_ptr Automatable::automation_control (const Evoral::Parameter& id, bool create) { @@ -492,47 +613,56 @@ Automatable::clear_controls () ControlSet::clear_controls (); } -string -Automatable::value_as_string (boost::shared_ptr ac) const -{ - return ARDOUR::value_as_string(ac->desc(), ac->get_value()); -} - bool -Automatable::find_next_event (double now, double end, Evoral::ControlEvent& next_event, bool only_active) const +Automatable::find_next_event (double start, double end, Evoral::ControlEvent& next_event, bool only_active) const { - Controls::const_iterator li; - next_event.when = std::numeric_limits::max(); - for (li = _controls.begin(); li != _controls.end(); ++li) { - boost::shared_ptr c - = boost::dynamic_pointer_cast(li->second); - - if (only_active && (!c || !c->automation_playback())) { - continue; - } - - Evoral::ControlList::const_iterator i; - boost::shared_ptr alist (li->second->list()); - Evoral::ControlEvent cp (now, 0.0f); - if (!alist) { - continue; + if (only_active) { + boost::shared_ptr cl = _automated_controls.reader (); + for (ControlList::const_iterator ci = cl->begin(); ci != cl->end(); ++ci) { + if ((*ci)->automation_playback()) { + find_next_ac_event (*ci, start, end, next_event); + } } - - for (i = lower_bound (alist->begin(), alist->end(), &cp, Evoral::ControlList::time_comparator); - i != alist->end() && (*i)->when < end; ++i) { - if ((*i)->when > now) { - break; + } else { + for (Controls::const_iterator li = _controls.begin(); li != _controls.end(); ++li) { + boost::shared_ptr c + = boost::dynamic_pointer_cast(li->second); + if (c) { + find_next_ac_event (c, start, end, next_event); } } + } + return next_event.when != std::numeric_limits::max(); +} - if (i != alist->end() && (*i)->when < end) { - if ((*i)->when < next_event.when) { - next_event.when = (*i)->when; - } +void +Automatable::find_next_ac_event (boost::shared_ptr c, double start, double end, Evoral::ControlEvent& next_event) const +{ + boost::shared_ptr sc + = boost::dynamic_pointer_cast(c); + + if (sc) { + sc->find_next_event (start, end, next_event); + } + + Evoral::ControlList::const_iterator i; + boost::shared_ptr alist (c->list()); + Evoral::ControlEvent cp (start, 0.0f); + if (!alist) { + return; + } + + for (i = lower_bound (alist->begin(), alist->end(), &cp, Evoral::ControlList::time_comparator); i != alist->end() && (*i)->when < end; ++i) { + if ((*i)->when > start) { + break; } } - return next_event.when != std::numeric_limits::max(); + if (i != alist->end() && (*i)->when < end) { + if ((*i)->when < next_event.when) { + next_event.when = (*i)->when; + } + } }