libs/ardour/automation_list.cc

   1 /*
   2     Copyright (C) 2002 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 <set>
  21 #include <climits>
  22 #include <float.h>
  23 #include <cmath>
  24 #include <sstream>
  25 #include <algorithm>
  26 #include "ardour/automation_list.h"
  27 #include "ardour/event_type_map.h"
  28 #include "evoral/Curve.hpp"
  29 #include "pbd/stacktrace.h"
  30 #include "pbd/enumwriter.h"
  31
  32 #include "i18n.h"
  33
  34 using namespace std;
  35 using namespace ARDOUR;
  36 using namespace PBD;
  37
  38 PBD::Signal1<void,AutomationList *> AutomationList::AutomationListCreated;
  39
  40 #if 0
  41 static void dumpit (const AutomationList& al, string prefix = "")
  42 {
  43         cerr << prefix << &al << endl;
  44         for (AutomationList::const_iterator i = al.begin(); i != al.end(); ++i) {
  45                 cerr << prefix << '\t' << (*i)->when << ',' << (*i)->value << endl;
  46         }
  47         cerr << "\n";
  48 }
  49 #endif
  50 AutomationList::AutomationList (Evoral::Parameter id)
  51         : ControlList(id)
  52 {
  53         _state = Off;
  54         _style = Absolute;
  55         g_atomic_int_set (&_touching, 0);
  56
  57         create_curve_if_necessary();
  58
  59         assert(_parameter.type() != NullAutomation);
  60         AutomationListCreated(this);
  61 }
  62
  63 AutomationList::AutomationList (const AutomationList& other)
  64         : StatefulDestructible()
  65         , ControlList(other)
  66 {
  67         _style = other._style;
  68         _state = other._state;
  69         g_atomic_int_set (&_touching, other.touching());
  70
  71         create_curve_if_necessary();
  72
  73         assert(_parameter.type() != NullAutomation);
  74         AutomationListCreated(this);
  75 }
  76
  77 AutomationList::AutomationList (const AutomationList& other, double start, double end)
  78         : ControlList(other, start, end)
  79 {
  80         _style = other._style;
  81         _state = other._state;
  82         g_atomic_int_set (&_touching, other.touching());
  83
  84         create_curve_if_necessary();
  85
  86         assert(_parameter.type() != NullAutomation);
  87         AutomationListCreated(this);
  88 }
  89
  90 /** @param id is used for legacy sessions where the type is not present
  91  * in or below the AutomationList node.  It is used if @param id is non-null.
  92  */
  93 AutomationList::AutomationList (const XMLNode& node, Evoral::Parameter id)
  94         : ControlList(id)
  95 {
  96         g_atomic_int_set (&_touching, 0);
  97         _state = Off;
  98         _style = Absolute;
  99
 100         set_state (node, Stateful::loading_state_version);
 101
 102         if (id) {
 103                 _parameter = id;
 104         }
 105
 106         create_curve_if_necessary();
 107
 108         assert(_parameter.type() != NullAutomation);
 109         AutomationListCreated(this);
 110 }
 111
 112 AutomationList::~AutomationList()
 113 {
 114 }
 115
 116 boost::shared_ptr<Evoral::ControlList>
 117 AutomationList::create(Evoral::Parameter id)
 118 {
 119         return boost::shared_ptr<Evoral::ControlList>(new AutomationList(id));
 120 }
 121
 122 void
 123 AutomationList::create_curve_if_necessary()
 124 {
 125         switch (_parameter.type()) {
 126         case GainAutomation:
 127         case PanAzimuthAutomation:
 128         case PanElevationAutomation:
 129         case PanWidthAutomation:
 130         case FadeInAutomation:
 131         case FadeOutAutomation:
 132         case EnvelopeAutomation:
 133                 create_curve();
 134                 break;
 135         default:
 136                 break;
 137         }
 138 }
 139
 140 bool
 141 AutomationList::operator== (const AutomationList& other)
 142 {
 143         return _events == other._events;
 144 }
 145
 146 AutomationList&
 147 AutomationList::operator= (const AutomationList& other)
 148 {
 149         if (this != &other) {
 150
 151                 _events.clear ();
 152
 153                 for (const_iterator i = other._events.begin(); i != other._events.end(); ++i) {
 154                         _events.push_back (new Evoral::ControlEvent (**i));
 155                 }
 156
 157                 _min_yval = other._min_yval;
 158                 _max_yval = other._max_yval;
 159                 _default_value = other._default_value;
 160
 161                 mark_dirty ();
 162                 maybe_signal_changed ();
 163         }
 164
 165         return *this;
 166 }
 167
 168 void
 169 AutomationList::maybe_signal_changed ()
 170 {
 171         ControlList::maybe_signal_changed ();
 172
 173         if (!ControlList::frozen()) {
 174                 StateChanged (); /* EMIT SIGNAL */
 175         }
 176 }
 177
 178 void
 179 AutomationList::set_automation_state (AutoState s)
 180 {
 181         if (s != _state) {
 182                 _state = s;
 183                 automation_state_changed (s); /* EMIT SIGNAL */
 184         }
 185 }
 186
 187 void
 188 AutomationList::set_automation_style (AutoStyle s)
 189 {
 190         if (s != _style) {
 191                 _style = s;
 192                 automation_style_changed (); /* EMIT SIGNAL */
 193         }
 194 }
 195
 196 void
 197 AutomationList::start_touch (double when)
 198 {
 199         if (_state == Touch) {
 200                 start_write_pass (when);
 201         }
 202
 203         g_atomic_int_set (&_touching, 1);
 204 }
 205
 206 void
 207 AutomationList::stop_touch (bool mark, double when)
 208 {
 209         if (g_atomic_int_get (&_touching) == 0) {
 210                 /* this touch has already been stopped (probably by Automatable::transport_stopped),
 211                    so we've nothing to do.
 212                 */
 213                 return;
 214         }
 215
 216         g_atomic_int_set (&_touching, 0);
 217
 218         if (_state == Touch) {
 219
 220                 if (mark) {
 221
 222                         /* XXX need to mark the last added point with the
 223                          * current time
 224                          */
 225                 }
 226         }
 227 }
 228
 229 void
 230 AutomationList::thaw ()
 231 {
 232         ControlList::thaw();
 233
 234         if (_changed_when_thawed) {
 235                 _changed_when_thawed = false;
 236                 StateChanged(); /* EMIT SIGNAL */
 237         }
 238 }
 239
 240 XMLNode&
 241 AutomationList::get_state ()
 242 {
 243         return state (true);
 244 }
 245
 246 XMLNode&
 247 AutomationList::state (bool full)
 248 {
 249         XMLNode* root = new XMLNode (X_("AutomationList"));
 250         char buf[64];
 251         LocaleGuard lg (X_("POSIX"));
 252
 253         root->add_property ("automation-id", EventTypeMap::instance().to_symbol(_parameter));
 254
 255         root->add_property ("id", id().to_s());
 256
 257         snprintf (buf, sizeof (buf), "%.12g", _default_value);
 258         root->add_property ("default", buf);
 259         snprintf (buf, sizeof (buf), "%.12g", _min_yval);
 260         root->add_property ("min-yval", buf);
 261         snprintf (buf, sizeof (buf), "%.12g", _max_yval);
 262         root->add_property ("max-yval", buf);
 263
 264         root->add_property ("interpolation-style", enum_2_string (_interpolation));
 265
 266         if (full) {
 267                 /* never serialize state with Write enabled - too dangerous
 268                    for the user's data
 269                 */
 270                 if (_state != Write) {
 271                         root->add_property ("state", auto_state_to_string (_state));
 272                 } else {
 273                         root->add_property ("state", auto_state_to_string (Off));
 274                 }
 275         } else {
 276                 /* never save anything but Off for automation state to a template */
 277                 root->add_property ("state", auto_state_to_string (Off));
 278         }
 279
 280         root->add_property ("style", auto_style_to_string (_style));
 281
 282         if (!_events.empty()) {
 283                 root->add_child_nocopy (serialize_events());
 284         }
 285
 286         return *root;
 287 }
 288
 289 XMLNode&
 290 AutomationList::serialize_events ()
 291 {
 292         XMLNode* node = new XMLNode (X_("events"));
 293         stringstream str;
 294
 295         str.precision(15);  //10 digits is enough digits for 24 hours at 96kHz
 296
 297         for (iterator xx = _events.begin(); xx != _events.end(); ++xx) {
 298                 str << (double) (*xx)->when;
 299                 str << ' ';
 300                 str <<(double) (*xx)->value;
 301                 str << '\n';
 302         }
 303
 304         /* XML is a bit wierd */
 305
 306         XMLNode* content_node = new XMLNode (X_("foo")); /* it gets renamed by libxml when we set content */
 307         content_node->set_content (str.str());
 308
 309         node->add_child_nocopy (*content_node);
 310
 311         return *node;
 312 }
 313
 314 int
 315 AutomationList::deserialize_events (const XMLNode& node)
 316 {
 317         if (node.children().empty()) {
 318                 return -1;
 319         }
 320
 321         XMLNode* content_node = node.children().front();
 322
 323         if (content_node->content().empty()) {
 324                 return -1;
 325         }
 326
 327         ControlList::freeze ();
 328         clear ();
 329
 330         stringstream str (content_node->content());
 331
 332         double x;
 333         double y;
 334         bool ok = true;
 335
 336         while (str) {
 337                 str >> x;
 338                 if (!str) {
 339                         break;
 340                 }
 341                 str >> y;
 342                 if (!str) {
 343                         ok = false;
 344                         break;
 345                 }
 346                 fast_simple_add (x, y);
 347         }
 348
 349         thin ();
 350
 351         if (!ok) {
 352                 clear ();
 353                 error << _("automation list: cannot load coordinates from XML, all points ignored") << endmsg;
 354         } else {
 355                 mark_dirty ();
 356                 maybe_signal_changed ();
 357         }
 358
 359         thaw ();
 360
 361         return 0;
 362 }
 363
 364 int
 365 AutomationList::set_state (const XMLNode& node, int version)
 366 {
 367         LocaleGuard lg (X_("POSIX"));
 368         XMLNodeList nlist = node.children();
 369         XMLNode* nsos;
 370         XMLNodeIterator niter;
 371         const XMLProperty* prop;
 372
 373         if (node.name() == X_("events")) {
 374                 /* partial state setting*/
 375                 return deserialize_events (node);
 376         }
 377
 378         if (node.name() == X_("Envelope") || node.name() == X_("FadeOut") || node.name() == X_("FadeIn")) {
 379
 380                 if ((nsos = node.child (X_("AutomationList")))) {
 381                         /* new school in old school clothing */
 382                         return set_state (*nsos, version);
 383                 }
 384
 385                 /* old school */
 386
 387                 const XMLNodeList& elist = node.children();
 388                 XMLNodeConstIterator i;
 389                 XMLProperty* prop;
 390                 pframes_t x;
 391                 double y;
 392
 393                 ControlList::freeze ();
 394                 clear ();
 395
 396                 for (i = elist.begin(); i != elist.end(); ++i) {
 397
 398                         if ((prop = (*i)->property ("x")) == 0) {
 399                                 error << _("automation list: no x-coordinate stored for control point (point ignored)") << endmsg;
 400                                 continue;
 401                         }
 402                         x = atoi (prop->value().c_str());
 403
 404                         if ((prop = (*i)->property ("y")) == 0) {
 405                                 error << _("automation list: no y-coordinate stored for control point (point ignored)") << endmsg;
 406                                 continue;
 407                         }
 408                         y = atof (prop->value().c_str());
 409
 410                         fast_simple_add (x, y);
 411                 }
 412
 413                 thin ();
 414
 415                 thaw ();
 416
 417                 return 0;
 418         }
 419
 420         if (node.name() != X_("AutomationList") ) {
 421                 error << string_compose (_("AutomationList: passed XML node called %1, not \"AutomationList\" - ignored"), node.name()) << endmsg;
 422                 return -1;
 423         }
 424
 425         if (set_id (node)) {
 426                 /* update session AL list */
 427                 AutomationListCreated(this);
 428         }
 429
 430         if ((prop = node.property (X_("automation-id"))) != 0){
 431                 _parameter = EventTypeMap::instance().new_parameter(prop->value());
 432         } else {
 433                 warning << "Legacy session: automation list has no automation-id property.";
 434         }
 435
 436         if ((prop = node.property (X_("interpolation-style"))) != 0) {
 437                 _interpolation = (InterpolationStyle)string_2_enum(prop->value(), _interpolation);
 438         } else {
 439                 _interpolation = Linear;
 440         }
 441
 442         if ((prop = node.property (X_("default"))) != 0){
 443                 _default_value = atof (prop->value().c_str());
 444         } else {
 445                 _default_value = 0.0;
 446         }
 447
 448         if ((prop = node.property (X_("style"))) != 0) {
 449                 _style = string_to_auto_style (prop->value());
 450         } else {
 451                 _style = Absolute;
 452         }
 453
 454         if ((prop = node.property (X_("state"))) != 0) {
 455                 _state = string_to_auto_state (prop->value());
 456                 if (_state == Write) {
 457                         _state = Off;
 458                 }
 459         } else {
 460                 _state = Off;
 461         }
 462
 463         if ((prop = node.property (X_("min-yval"))) != 0) {
 464                 _min_yval = atof (prop->value ().c_str());
 465         } else {
 466                 _min_yval = FLT_MIN;
 467         }
 468
 469         if ((prop = node.property (X_("max-yval"))) != 0) {
 470                 _max_yval = atof (prop->value ().c_str());
 471         } else {
 472                 _max_yval = FLT_MAX;
 473         }
 474
 475         bool have_events = false;
 476
 477         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 478                 if ((*niter)->name() == X_("events")) {
 479                         deserialize_events (*(*niter));
 480                         have_events = true;
 481                 }
 482         }
 483
 484         if (!have_events) {
 485                 /* there was no Events child node; clear any current events */
 486                 freeze ();
 487                 clear ();
 488                 mark_dirty ();
 489                 maybe_signal_changed ();
 490                 thaw ();
 491         }
 492
 493         return 0;
 494 }
 495
 496 bool
 497 AutomationList::operator!= (AutomationList const & other) const
 498 {
 499         return (
 500                 static_cast<ControlList const &> (*this) != static_cast<ControlList const &> (other) ||
 501                 _state != other._state ||
 502                 _style != other._style ||
 503                 _touching != other._touching
 504                 );
 505 }
 506
 507 PBD::PropertyBase *
 508 AutomationListProperty::clone () const
 509 {
 510         return new AutomationListProperty (
 511                 this->property_id(),
 512                 boost::shared_ptr<AutomationList> (new AutomationList (*this->_old.get())),
 513                 boost::shared_ptr<AutomationList> (new AutomationList (*this->_current.get()))
 514                 );
 515 }
 516