libs/ardour/automatable.cc

   1 /*
   2     Copyright (C) 2001,2007 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 <ardour/ardour.h>
  21 #include <fstream>
  22 #include <inttypes.h>
  23 #include <cstdio>
  24 #include <errno.h>
  25 #include <pbd/error.h>
  26 #include <pbd/enumwriter.h>
  27 #include <ardour/session.h>
  28 #include <ardour/automatable.h>
  29
  30 #include "i18n.h"
  31
  32 using namespace std;
  33 using namespace ARDOUR;
  34 using namespace PBD;
  35
  36
  37 Automatable::Automatable(Session& _session, const string& name)
  38         : SessionObject(_session, name)
  39         , _last_automation_snapshot(0)
  40 {}
  41
  42 int
  43 Automatable::old_set_automation_state (const XMLNode& node)
  44 {
  45         const XMLProperty *prop;
  46
  47         if ((prop = node.property ("path")) != 0) {
  48                 load_automation (prop->value());
  49         } else {
  50                 warning << string_compose(_("%1: Automation node has no path property"), _name) << endmsg;
  51         }
  52
  53         if ((prop = node.property ("visible")) != 0) {
  54                 uint32_t what;
  55                 stringstream sstr;
  56
  57                 _visible_controls.clear ();
  58
  59                 sstr << prop->value();
  60                 while (1) {
  61                         sstr >> what;
  62                         if (sstr.fail()) {
  63                                 break;
  64                         }
  65                         mark_automation_visible (Parameter(PluginAutomation, what), true);
  66                 }
  67         }
  68
  69         _last_automation_snapshot = 0;
  70
  71         return 0;
  72 }
  73
  74 int
  75 Automatable::load_automation (const string& path)
  76 {
  77         string fullpath;
  78
  79         if (path[0] == '/') { // legacy
  80                 fullpath = path;
  81         } else {
  82                 fullpath = _session.automation_dir();
  83                 fullpath += path;
  84         }
  85         ifstream in (fullpath.c_str());
  86
  87         if (!in) {
  88                 warning << string_compose(_("%1: cannot open %2 to load automation data (%3)"), _name, fullpath, strerror (errno)) << endmsg;
  89                 return 1;
  90         }
  91
  92         Glib::Mutex::Lock lm (_automation_lock);
  93         set<Parameter> tosave;
  94         _controls.clear ();
  95
  96         _last_automation_snapshot = 0;
  97
  98         while (in) {
  99                 double when;
 100                 double value;
 101                 uint32_t port;
 102
 103                 in >> port;  if (!in) break;
 104                 in >> when;  if (!in) goto bad;
 105                 in >> value; if (!in) goto bad;
 106
 107                 /* FIXME: this is legacy and only used for plugin inserts?  I think? */
 108                 boost::shared_ptr<AutomationControl> c = control (Parameter(PluginAutomation, port), true);
 109                 c->list()->add (when, value);
 110                 tosave.insert (Parameter(PluginAutomation, port));
 111         }
 112
 113         return 0;
 114
 115   bad:
 116         error << string_compose(_("%1: cannot load automation data from %2"), _name, fullpath) << endmsg;
 117         _controls.clear ();
 118         return -1;
 119 }
 120
 121 void
 122 Automatable::add_control(boost::shared_ptr<AutomationControl> ac)
 123 {
 124         Parameter param = ac->parameter();
 125
 126         _controls[param] = ac;
 127
 128         cerr << _name << ": added parameter " << param.to_string() << endl;
 129
 130         _can_automate_list.insert(param);
 131
 132         // Sync everything (derived classes) up to initial values
 133         auto_state_changed(param);
 134 }
 135
 136 void
 137 Automatable::what_has_automation (set<Parameter>& s) const
 138 {
 139         Glib::Mutex::Lock lm (_automation_lock);
 140         Controls::const_iterator li;
 141
 142         // FIXME: correct semantics?
 143         for (li = _controls.begin(); li != _controls.end(); ++li) {
 144                 s.insert  ((*li).first);
 145         }
 146 }
 147
 148 void
 149 Automatable::what_has_visible_automation (set<Parameter>& s) const
 150 {
 151         Glib::Mutex::Lock lm (_automation_lock);
 152         set<Parameter>::const_iterator li;
 153
 154         for (li = _visible_controls.begin(); li != _visible_controls.end(); ++li) {
 155                 s.insert  (*li);
 156         }
 157 }
 158
 159 /** Returns NULL if we don't have an AutomationList for \a parameter.
 160  */
 161 boost::shared_ptr<AutomationControl>
 162 Automatable::control (Parameter parameter, bool create_if_missing)
 163 {
 164         Controls::iterator i = _controls.find(parameter);
 165
 166         if (i != _controls.end()) {
 167                 return i->second;
 168
 169         } else if (create_if_missing) {
 170                 boost::shared_ptr<AutomationList> al (new AutomationList (
 171                                         parameter, FLT_MIN, FLT_MAX, default_parameter_value (parameter)));
 172                 boost::shared_ptr<AutomationControl> ac (new AutomationControl(_session, al));
 173                 add_control(ac);
 174                 cerr << "WARNING: Default AutomationControl created for " << parameter.to_string() << endl;
 175                 return ac;
 176
 177         } else {
 178                 //warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg;
 179                 return boost::shared_ptr<AutomationControl>();
 180         }
 181 }
 182
 183 boost::shared_ptr<const AutomationControl>
 184 Automatable::control (Parameter parameter) const
 185 {
 186         Controls::const_iterator i = _controls.find(parameter);
 187
 188         if (i != _controls.end()) {
 189                 return i->second;
 190         } else {
 191                 //warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg;
 192                 return boost::shared_ptr<AutomationControl>();
 193         }
 194 }
 195
 196
 197 string
 198 Automatable::describe_parameter (Parameter param)
 199 {
 200         /* derived classes like PluginInsert should override this */
 201
 202         if (param == Parameter(GainAutomation))
 203                 return _("Fader");
 204         else if (param.type() == PanAutomation)
 205                 return (string_compose(_("Pan %1"), param.id()));
 206         else if (param.type() == MidiCCAutomation)
 207                 return string_compose("CC %1", param.id());
 208         else
 209                 return param.to_string();
 210 }
 211
 212 void
 213 Automatable::can_automate (Parameter what)
 214 {
 215         _can_automate_list.insert (what);
 216 }
 217
 218 void
 219 Automatable::mark_automation_visible (Parameter what, bool yn)
 220 {
 221         if (yn) {
 222                 _visible_controls.insert (what);
 223         } else {
 224                 set<Parameter>::iterator i;
 225
 226                 if ((i = _visible_controls.find (what)) != _visible_controls.end()) {
 227                         _visible_controls.erase (i);
 228                 }
 229         }
 230 }
 231
 232 bool
 233 Automatable::find_next_event (nframes_t now, nframes_t end, ControlEvent& next_event) const
 234 {
 235         Controls::const_iterator li;
 236         AutomationList::TimeComparator cmp;
 237
 238         next_event.when = max_frames;
 239
 240         for (li = _controls.begin(); li != _controls.end(); ++li) {
 241
 242                 AutomationList::const_iterator i;
 243                 boost::shared_ptr<const AutomationList> alist (li->second->list());
 244                 ControlEvent cp (now, 0.0f);
 245
 246                 for (i = lower_bound (alist->const_begin(), alist->const_end(), &cp, cmp); i != alist->const_end() && (*i)->when < end; ++i) {
 247                         if ((*i)->when > now) {
 248                                 break;
 249                         }
 250                 }
 251
 252                 if (i != alist->const_end() && (*i)->when < end) {
 253
 254                         if ((*i)->when < next_event.when) {
 255                                 next_event.when = (*i)->when;
 256                         }
 257                 }
 258         }
 259
 260         return next_event.when != max_frames;
 261 }
 262
 263 /** \a legacy_param is used for loading legacy sessions where an object (IO, Panner)
 264  * had a single automation parameter, with it's type implicit.  Derived objects should
 265  * pass that type and it will be used for the untyped AutomationList found.
 266  */
 267 int
 268 Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param)
 269 {
 270         Glib::Mutex::Lock lm (_automation_lock);
 271
 272         /* Don't clear controls, since some may be special derived Controllable classes */
 273
 274         _visible_controls.clear ();
 275
 276         XMLNodeList nlist = node.children();
 277         XMLNodeIterator niter;
 278
 279         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 280
 281                 /*if (sscanf ((*niter)->name().c_str(), "parameter-%" PRIu32, &param) != 1) {
 282                   error << string_compose (_("%2: badly formatted node name in XML automation state, ignored"), _name) << endmsg;
 283                   continue;
 284                   }*/
 285
 286                 if ((*niter)->name() == "AutomationList") {
 287
 288                         const XMLProperty* id_prop = (*niter)->property("automation-id");
 289
 290                         Parameter param = (id_prop ? Parameter(id_prop->value()) : legacy_param);
 291
 292                         boost::shared_ptr<AutomationList> al (new AutomationList(**niter, param));
 293
 294                         if (!id_prop) {
 295                                 warning << "AutomationList node without automation-id property, "
 296                                         << "using default: " << legacy_param.to_string() << endmsg;
 297                                 al->set_param_id(legacy_param);
 298                         }
 299
 300                         boost::shared_ptr<AutomationControl> existing = control(param);
 301                         if (existing)
 302                                 existing->set_list(al);
 303                         else
 304                                 add_control(boost::shared_ptr<AutomationControl>(new AutomationControl(_session, al)));
 305
 306                 } else {
 307                         error << "Expected AutomationList node, got '" << (*niter)->name() << endmsg;
 308                 }
 309         }
 310
 311         _last_automation_snapshot = 0;
 312
 313         return 0;
 314 }
 315
 316 XMLNode&
 317 Automatable::get_automation_state ()
 318 {
 319         Glib::Mutex::Lock lm (_automation_lock);
 320         XMLNode* node = new XMLNode (X_("Automation"));
 321
 322         if (_controls.empty()) {
 323                 return *node;
 324         }
 325
 326         for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) {
 327                 node->add_child_nocopy (li->second->list()->get_state ());
 328         }
 329
 330         return *node;
 331 }
 332
 333 void
 334 Automatable::clear_automation ()
 335 {
 336         Glib::Mutex::Lock lm (_automation_lock);
 337
 338         for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li)
 339                 li->second->list()->clear();
 340 }
 341
 342 void
 343 Automatable::set_parameter_automation_state (Parameter param, AutoState s)
 344 {
 345         Glib::Mutex::Lock lm (_automation_lock);
 346
 347         boost::shared_ptr<AutomationControl> c = control (param, true);
 348
 349         if (s != c->list()->automation_state()) {
 350                 c->list()->set_automation_state (s);
 351                 _session.set_dirty ();
 352         }
 353 }
 354
 355 AutoState
 356 Automatable::get_parameter_automation_state (Parameter param, bool lock)
 357 {
 358         AutoState result = Off;
 359
 360         if (lock)
 361                 _automation_lock.lock();
 362
 363         boost::shared_ptr<AutomationControl> c = control(param);
 364
 365         if (c)
 366                 result = c->list()->automation_state();
 367
 368         if (lock)
 369                 _automation_lock.unlock();
 370
 371         return result;
 372 }
 373
 374 void
 375 Automatable::set_parameter_automation_style (Parameter param, AutoStyle s)
 376 {
 377         Glib::Mutex::Lock lm (_automation_lock);
 378
 379         boost::shared_ptr<AutomationControl> c = control(param, true);
 380
 381         if (s != c->list()->automation_style()) {
 382                 c->list()->set_automation_style (s);
 383                 _session.set_dirty ();
 384         }
 385 }
 386
 387 AutoStyle
 388 Automatable::get_parameter_automation_style (Parameter param)
 389 {
 390         Glib::Mutex::Lock lm (_automation_lock);
 391
 392         boost::shared_ptr<AutomationControl> c = control(param);
 393
 394         if (c) {
 395                 return c->list()->automation_style();
 396         } else {
 397                 return Absolute; // whatever
 398         }
 399 }
 400
 401 void
 402 Automatable::protect_automation ()
 403 {
 404         set<Parameter> automated_params;
 405
 406         what_has_automation (automated_params);
 407
 408         for (set<Parameter>::iterator i = automated_params.begin(); i != automated_params.end(); ++i) {
 409
 410                 boost::shared_ptr<AutomationControl> c = control(*i);
 411
 412                 switch (c->list()->automation_state()) {
 413                 case Write:
 414                         c->list()->set_automation_state (Off);
 415                         break;
 416                 case Touch:
 417                         c->list()->set_automation_state (Play);
 418                         break;
 419                 default:
 420                         break;
 421                 }
 422         }
 423 }
 424
 425 void
 426 Automatable::automation_snapshot (nframes_t now)
 427 {
 428         if (_last_automation_snapshot > now || (now - _last_automation_snapshot) > _session.automation_interval()) {
 429
 430                 for (Controls::iterator i = _controls.begin(); i != _controls.end(); ++i) {
 431                         if (i->second->list()->automation_write()) {
 432                                 i->second->list()->rt_add (now, i->second->user_value());
 433                         }
 434                 }
 435
 436                 _last_automation_snapshot = now;
 437         }
 438 }
 439
 440 void
 441 Automatable::transport_stopped (nframes_t now)
 442 {
 443         for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) {
 444
 445                 boost::shared_ptr<AutomationControl> c = li->second;
 446
 447                 c->list()->reposition_for_rt_add (now);
 448
 449                 if (c->list()->automation_state() != Off) {
 450                         c->set_value(c->list()->eval(now));
 451                 }
 452         }
 453 }
 454