(1) do not write sequential same-value automation data into a ControlList (2) thin...

git-svn-id: svn://localhost/ardour2/branches/3.0@11078 d708f5d6-7413-0410-9779-e7cbd77b26cf

diff --git a/libs/ardour/automation_list.cc b/libs/ardour/automation_list.cc
index 2e28bb8bb16bb82acd835b0af440ac0a406d3b52..0810d2f2d007bb45c59eb8970d76e3048f6f5357 100644 (file)
--- a/libs/ardour/automation_list.cc
+++ b/libs/ardour/automation_list.cc
@@ -366,6 +366,8 @@ AutomationList::deserialize_events (const XMLNode& node)
                fast_simple_add (x, y);
        }
 
+       thin ();
+
        if (!ok) {
                clear ();
                error << _("automation list: cannot load coordinates from XML, all points ignored") << endmsg;
@@ -427,6 +429,8 @@ AutomationList::set_state (const XMLNode& node, int version)
                        fast_simple_add (x, y);
                }
 
+               thin ();
+
                 thaw ();
 
                return 0;

diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index 18ee9096899a590980d117a5d68e4f5c7a2a40f1..00507627b5ee353cb2c9d951af8e72c1a2e63a6e 100644 (file)
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -504,6 +504,7 @@ Route::process_output_buffers (BufferSet& bufs,
                        }
                }
 #endif
+
                /* should we NOT run plugins here if the route is inactive?
                   do we catch route != active somewhere higher?
                */

diff --git a/libs/evoral/evoral/ControlList.hpp b/libs/evoral/evoral/ControlList.hpp
index 792de036a61bc76092e5dc1b0e60500875dd0c21..286974676f87a741dcabde370aa6b890fe9b93fc 100644 (file)
--- a/libs/evoral/evoral/ControlList.hpp
+++ b/libs/evoral/evoral/ControlList.hpp
@@ -130,6 +130,8 @@ public:
        bool move_ranges (std::list< RangeMove<double> > const &);
        void modify (iterator, double, double);
 
+        void thin ();
+
        boost::shared_ptr<ControlList> cut (double, double);
        boost::shared_ptr<ControlList> copy (double, double);
        void clear (double, double);

diff --git a/libs/evoral/src/ControlList.cpp b/libs/evoral/src/ControlList.cpp
index 222f72958f90650b2a8fc4dc11cdac8c67907853..d3532eaefe26e3986c5da86ea5dd7a6636c48d8c 100644 (file)
--- a/libs/evoral/src/ControlList.cpp
+++ b/libs/evoral/src/ControlList.cpp
@@ -390,7 +390,67 @@ ControlList::rt_add (double when, double value)
                /* we don't worry about adding events out of time order as we will
                   sort them in merge_nascent.
                */
-               nascent.back()->events.push_back (new ControlEvent (when, value));
+
+               EventList& el (nascent.back()->events);
+
+               if (el.size() > 1 && (when >= el.back()->when) && (value == el.back()->value)) {
+                       /* same value, later timestamp, effective slope is
+                        * zero, so just move the last point in nascent to our
+                        * new time position. this avoids storing an unlimited
+                        * number of points to represent a flat line.
+                        */
+                       el.back()->when = when;
+               } else {
+                       nascent.back()->events.push_back (new ControlEvent (when, value));
+               }
+       }
+}
+
+void
+ControlList::thin ()
+{
+       Glib::Mutex::Lock lm (_lock);
+
+       ControlEvent* prevprev;
+       ControlEvent* cur;
+       ControlEvent* prev;
+       iterator pprev;
+       int counter = 0;
+
+       for (iterator i = _events.begin(); i != _events.end(); ++i) {
+
+               cur = *i;
+               counter++;
+
+               if (counter > 2) {
+                       
+                       double area = fabs (0.5 * 
+                                           (prevprev->when * (prev->value - cur->value)) + 
+                                           (prev->when * (cur->value - prevprev->value)) + 
+                                           (cur->when * (prevprev->value - prev->value)));
+                       
+                       /* the number 10.0 is an arbitrary value that needs to
+                        * be controlled by some user-controllable
+                        * configuration utility.
+                        */
+
+                       if (area < 10.0) {
+                               iterator tmp = pprev;
+
+                               /* pprev will change to current
+                                  i is incremented to the next event
+                               */
+
+                               pprev = i;
+                               _events.erase (tmp);
+
+                               continue;
+                       }
+               }
+
+               prevprev = prev;
+               prev = cur;
+               pprev = i;
        }
 }
 

diff --git a/libs/evoral/src/Curve.cpp b/libs/evoral/src/Curve.cpp
index 61487098c2ce204fc95a2d531bbe7cf09cfad220..dd327d488a8fd0803eb27b8a2ffd1ea6e5c69ab4 100644 (file)
--- a/libs/evoral/src/Curve.cpp
+++ b/libs/evoral/src/Curve.cpp
@@ -124,7 +124,6 @@ Curve::solve ()
                                } else {
                                        fpi = 2 / (slope_before + slope_after);
                                }
-
                        }
 
                        /* compute second derivative for either side of control point `i' */
@@ -297,7 +296,6 @@ Curve::_get_vector (double x0, double x1, float *vec, int32_t veclen)
                for (i = 1; i < veclen; ++i) {
                        vec[i] = vec[i-1] + yfrac;
                }
-
                return;
        }