libs/ardour/automation_watch.cc

   1 /*
   2     Copyright (C) 2012 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <iostream>
  21
  22 #include "pbd/compose.h"
  23
  24 #include "ardour/automation_control.h"
  25 #include "ardour/automation_watch.h"
  26 #include "ardour/debug.h"
  27 #include "ardour/session.h"
  28
  29 using namespace ARDOUR;
  30 using namespace PBD;
  31
  32 AutomationWatch* AutomationWatch::_instance = 0;
  33
  34 AutomationWatch&
  35 AutomationWatch::instance ()
  36 {
  37         if (_instance == 0) {
  38                 _instance = new AutomationWatch;
  39         }
  40         return *_instance;
  41 }
  42
  43 AutomationWatch::AutomationWatch ()
  44         : _thread (0)
  45         , _run_thread (false)
  46 {
  47
  48 }
  49
  50 AutomationWatch::~AutomationWatch ()
  51 {
  52         if (_thread) {
  53                 _run_thread = false;
  54                 _thread->join ();
  55                 _thread = 0;
  56         }
  57
  58         Glib::Threads::Mutex::Lock lm (automation_watch_lock);
  59         automation_watches.clear ();
  60 }
  61
  62 void
  63 AutomationWatch::add_automation_watch (boost::shared_ptr<AutomationControl> ac)
  64 {
  65         Glib::Threads::Mutex::Lock lm (automation_watch_lock);
  66         DEBUG_TRACE (DEBUG::Automation, string_compose ("now watching control %1 for automation, astate = %2\n", ac->name(), enum_2_string (ac->automation_state())));
  67         automation_watches.insert (ac);
  68
  69         /* if an automation control is added here while the transport is
  70          * rolling, make sure that it knows that there is a write pass going
  71          * on, rather than waiting for the transport to start.
  72          */
  73
  74         if (_session && _session->transport_rolling() && ac->alist()->automation_write()) {
  75                 DEBUG_TRACE (DEBUG::Automation, string_compose ("\ttransport is rolling @ %1, audible = %2so enter write pass\n",
  76                                                                 _session->transport_speed(), _session->audible_frame()));
  77                 /* add a guard point since we are already moving */
  78                 ac->list()->set_in_write_pass (true, true, _session->audible_frame());
  79         }
  80
  81         /* we can't store shared_ptr<Destructible> in connections because it
  82          * creates reference cycles. we don't need to make the weak_ptr<>
  83          * explicit here, but it helps to remind us what is going on.
  84          */
  85
  86         boost::weak_ptr<AutomationControl> wac (ac);
  87         ac->DropReferences.connect_same_thread (*this, boost::bind (&AutomationWatch::remove_weak_automation_watch, this, wac));
  88 }
  89
  90 void
  91 AutomationWatch::remove_weak_automation_watch (boost::weak_ptr<AutomationControl> wac)
  92 {
  93         boost::shared_ptr<AutomationControl> ac = wac.lock();
  94
  95         if (!ac) {
  96                 return;
  97         }
  98
  99         remove_automation_watch (ac);
 100 }
 101
 102 void
 103 AutomationWatch::remove_automation_watch (boost::shared_ptr<AutomationControl> ac)
 104 {
 105         Glib::Threads::Mutex::Lock lm (automation_watch_lock);
 106         DEBUG_TRACE (DEBUG::Automation, string_compose ("remove control %1 from automation watch\n", ac->name()));
 107         automation_watches.erase (ac);
 108         ac->list()->set_in_write_pass (false);
 109 }
 110
 111 gint
 112 AutomationWatch::timer ()
 113 {
 114         if (!_session || !_session->transport_rolling()) {
 115                 return TRUE;
 116         }
 117
 118         {
 119                 Glib::Threads::Mutex::Lock lm (automation_watch_lock);
 120
 121                 framepos_t time = _session->audible_frame ();
 122
 123                 for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) {
 124                         if ((*aw)->alist()->automation_write()) {
 125                                 (*aw)->list()->add (time, (*aw)->user_double());
 126                         }
 127                 }
 128         }
 129
 130         return TRUE;
 131 }
 132
 133 void
 134 AutomationWatch::thread ()
 135 {
 136         while (_run_thread) {
 137                 usleep ((useconds_t) floor (Config->get_automation_interval_msecs() * 1000));
 138                 timer ();
 139         }
 140 }
 141
 142 void
 143 AutomationWatch::set_session (Session* s)
 144 {
 145         transport_connection.disconnect ();
 146
 147         if (_thread) {
 148                 _run_thread = false;
 149                 _thread->join ();
 150                 _thread = 0;
 151         }
 152
 153         SessionHandlePtr::set_session (s);
 154
 155         if (_session) {
 156                 _run_thread = true;
 157                 _thread = Glib::Threads::Thread::create (boost::bind (&AutomationWatch::thread, this));
 158
 159                 _session->TransportStateChange.connect_same_thread (transport_connection, boost::bind (&AutomationWatch::transport_state_change, this));
 160         }
 161 }
 162
 163 void
 164 AutomationWatch::transport_state_change ()
 165 {
 166         if (!_session) {
 167                 return;
 168         }
 169
 170         bool rolling = _session->transport_rolling();
 171
 172         {
 173                 Glib::Threads::Mutex::Lock lm (automation_watch_lock);
 174
 175                 for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) {
 176                         DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport state changed, speed %2, in write pass ? %3 writing ? %4\n",
 177                                                                         (*aw)->name(), _session->transport_speed(), rolling,
 178                                                                         (*aw)->alist()->automation_write()));
 179                         if (rolling && (*aw)->alist()->automation_write()) {
 180                                 (*aw)->list()->set_in_write_pass (true);
 181                         } else {
 182                                 (*aw)->list()->set_in_write_pass (false);
 183                         }
 184                 }
 185         }
 186 }