X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fautomation_watch.cc;h=f3e2ae5f816d53127ddc8c6846aa4c7eb088cd09;hb=ff301419b3ca88635744984350cb1643f144deeb;hp=91fe4d38edbcf727aa5830aa21dea432ee10adb0;hpb=37b1f5017e904005fae6b815b1519b3fa595d8d3;p=ardour.git diff --git a/libs/ardour/automation_watch.cc b/libs/ardour/automation_watch.cc index 91fe4d38ed..f3e2ae5f81 100644 --- a/libs/ardour/automation_watch.cc +++ b/libs/ardour/automation_watch.cc @@ -1,28 +1,32 @@ /* - Copyright (C) 2012 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 - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - -*/ + * Copyright (C) 2012-2017 Paul Davis + * Copyright (C) 2015-2018 Robin Gareus + * Copyright (C) 2015 Ben Loftis + * Copyright (C) 2015 Nick Mainsbridge + * + * 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 + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ #include #include #include "pbd/compose.h" +#include "pbd/pthread_utils.h" +#include "ardour/audioengine.h" #include "ardour/automation_control.h" #include "ardour/automation_watch.h" #include "ardour/debug.h" @@ -44,9 +48,10 @@ AutomationWatch::instance () AutomationWatch::AutomationWatch () : _thread (0) + , _last_time (0) , _run_thread (false) { - + } AutomationWatch::~AutomationWatch () @@ -59,6 +64,7 @@ AutomationWatch::~AutomationWatch () Glib::Threads::Mutex::Lock lm (automation_watch_lock); automation_watches.clear (); + automation_connections.clear (); } void @@ -66,7 +72,11 @@ AutomationWatch::add_automation_watch (boost::shared_ptr ac) { Glib::Threads::Mutex::Lock lm (automation_watch_lock); DEBUG_TRACE (DEBUG::Automation, string_compose ("now watching control %1 for automation, astate = %2\n", ac->name(), enum_2_string (ac->automation_state()))); - automation_watches.insert (ac); + std::pair r = automation_watches.insert (ac); + + if (!r.second) { + return; + } /* if an automation control is added here while the transport is * rolling, make sure that it knows that there is a write pass going @@ -74,19 +84,19 @@ AutomationWatch::add_automation_watch (boost::shared_ptr ac) */ if (_session && _session->transport_rolling() && ac->alist()->automation_write()) { - DEBUG_TRACE (DEBUG::Automation, string_compose ("\ttransport is rolling @ %1, audible = %2so enter write pass\n", - _session->transport_speed(), _session->audible_frame())); + DEBUG_TRACE (DEBUG::Automation, string_compose ("\ttransport is rolling @ %1, audible = %2so enter write pass\n", + _session->transport_speed(), _session->audible_sample())); /* add a guard point since we are already moving */ - ac->list()->set_in_write_pass (true, true, _session->audible_frame()); + ac->list()->set_in_write_pass (true, true, _session->audible_sample()); } /* we can't store shared_ptr in connections because it * creates reference cycles. we don't need to make the weak_ptr<> * explicit here, but it helps to remind us what is going on. */ - + boost::weak_ptr wac (ac); - ac->DropReferences.connect_same_thread (*this, boost::bind (&AutomationWatch::remove_weak_automation_watch, this, wac)); + ac->DropReferences.connect_same_thread (automation_connections[ac], boost::bind (&AutomationWatch::remove_weak_automation_watch, this, wac)); } void @@ -107,9 +117,35 @@ AutomationWatch::remove_automation_watch (boost::shared_ptr a Glib::Threads::Mutex::Lock lm (automation_watch_lock); DEBUG_TRACE (DEBUG::Automation, string_compose ("remove control %1 from automation watch\n", ac->name())); automation_watches.erase (ac); + automation_connections.erase (ac); ac->list()->set_in_write_pass (false); } +void +AutomationWatch::transport_stop_automation_watches (samplepos_t when) +{ + DEBUG_TRACE (DEBUG::Automation, "clear all automation watches\n"); + + AutomationWatches tmp; + + { + Glib::Threads::Mutex::Lock lm (automation_watch_lock); + /* copy automation watches */ + tmp = automation_watches; + /* clear existing container so that each + ::remove_automation_watch() call from + AutomationControl::stop_touch() is faster. + */ + + automation_watches.clear (); + automation_connections.clear (); + } + + for (AutomationWatches::iterator i = tmp.begin(); i != tmp.end(); ++i) { + (*i)->stop_touch (when); + } +} + gint AutomationWatch::timer () { @@ -120,13 +156,31 @@ AutomationWatch::timer () { Glib::Threads::Mutex::Lock lm (automation_watch_lock); - framepos_t time = _session->audible_frame (); - - for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) { - if ((*aw)->alist()->automation_write()) { - (*aw)->list()->add (time, (*aw)->user_double()); + samplepos_t time = _session->audible_sample (); + if (time > _last_time) { //we only write automation in the forward direction; this fixes automation-recording in a loop + for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) { + if ((*aw)->alist()->automation_write()) { + double val = (*aw)->user_double(); + boost::shared_ptr sc = boost::dynamic_pointer_cast (*aw); + if (sc) { + val = sc->reduce_by_masters (val, true); + } + (*aw)->list()->add (time, val, true); + } + } + } else if (time != _last_time) { //transport stopped or reversed. stop the automation pass and start a new one (for bonus points, someday store the previous pass in an undo record) + for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) { + DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport in rewind, speed %2, in write pass ? %3 writing ? %4\n", + (*aw)->name(), _session->transport_speed(), _session->transport_rolling(), + (*aw)->alist()->automation_write())); + (*aw)->list()->set_in_write_pass (false); + if ( (*aw)->alist()->automation_write() ) { + (*aw)->list()->set_in_write_pass (true, true, time); + } } } + + _last_time = time; } return TRUE; @@ -135,6 +189,7 @@ AutomationWatch::timer () void AutomationWatch::thread () { + pbd_set_thread_priority (pthread_self(), PBD_SCHED_FIFO, AudioEngine::instance()->client_real_time_priority() - 3); while (_run_thread) { Glib::usleep ((gulong) floor (Config->get_automation_interval_msecs() * 1000)); timer (); @@ -157,7 +212,7 @@ AutomationWatch::set_session (Session* s) if (_session) { _run_thread = true; _thread = Glib::Threads::Thread::create (boost::bind (&AutomationWatch::thread, this)); - + _session->TransportStateChange.connect_same_thread (transport_connection, boost::bind (&AutomationWatch::transport_state_change, this)); } } @@ -171,11 +226,13 @@ AutomationWatch::transport_state_change () bool rolling = _session->transport_rolling(); + _last_time = _session->audible_sample (); + { Glib::Threads::Mutex::Lock lm (automation_watch_lock); for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) { - DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport state changed, speed %2, in write pass ? %3 writing ? %4\n", + DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport state changed, speed %2, in write pass ? %3 writing ? %4\n", (*aw)->name(), _session->transport_speed(), rolling, (*aw)->alist()->automation_write())); if (rolling && (*aw)->alist()->automation_write()) {