Automatable::transport_stopped (framepos_t now)
{
for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) {
+ boost::shared_ptr<AutomationControl> c =
+ boost::dynamic_pointer_cast<AutomationControl>(li->second);
+ if (!c) {
+ continue;
+ }
- boost::shared_ptr<AutomationControl> c
- = boost::dynamic_pointer_cast<AutomationControl>(li->second);
- if (c) {
- boost::shared_ptr<AutomationList> l
- = boost::dynamic_pointer_cast<AutomationList>(c->list());
+ boost::shared_ptr<AutomationList> l =
+ boost::dynamic_pointer_cast<AutomationList>(c->list());
+ if (!l) {
+ continue;
+ }
- if (l) {
- /* Stop any active touch gesture just before we mark the write pass
- as finished. If we don't do this, the transport can end up stopped with
- an AutomationList thinking that a touch is still in progress and,
- when the transport is re-started, a touch will magically
- be happening without it ever have being started in the usual way.
- */
- l->stop_touch (true, now);
- l->write_pass_finished (now);
-
- if (l->automation_playback()) {
- c->set_value(c->list()->eval(now));
- }
-
- if (l->automation_state() == Write) {
- l->set_automation_state (Touch);
- }
- }
- }
+ /* Stop any active touch gesture just before we mark the write pass
+ as finished. If we don't do this, the transport can end up stopped with
+ an AutomationList thinking that a touch is still in progress and,
+ when the transport is re-started, a touch will magically
+ be happening without it ever have being started in the usual way.
+ */
+ l->stop_touch (true, now);
+ l->write_pass_finished (now, Config->get_automation_thinning_factor());
+
+ if (l->automation_playback()) {
+ c->set_value(c->list()->eval(now));
+ }
+
+ if (l->automation_state() == Write) {
+ l->set_automation_state (Touch);
+ }
}
}
last_timecode_valid = false;
} else if (p == "playback-buffer-seconds") {
AudioSource::allocate_working_buffers (frame_rate());
- } else if (p == "automation-thinning-factor") {
- Evoral::ControlList::set_thinning_factor (Config->get_automation_thinning_factor());
} else if (p == "ltc-source-port") {
reconnect_ltc_input ();
} else if (p == "ltc-sink-port") {
bool move_ranges (std::list< RangeMove<double> > const &);
void modify (iterator, double, double);
- void thin ();
+ /** Thin the number of events in this list.
+ *
+ * The thinning factor has no units but corresponds to the area of a
+ * triangle computed between three points in the list. If the area is
+ * large, it indicates significant non-linearity between the points.
+ *
+ * During automation recording we thin the recorded points using this
+ * value. If a point is sufficiently co-linear with its neighbours (as
+ * defined by the area of the triangle formed by three of them), we will
+ * not include it in the list. The larger the value, the more points are
+ * excluded, so this effectively measures the amount of thinning to be
+ * done.
+ */
+ void thin (double thinning_factor);
boost::shared_ptr<ControlList> cut (double, double);
boost::shared_ptr<ControlList> copy (double, double);
virtual bool writing() const { return false; }
virtual bool touch_enabled() const { return false; }
void start_write_pass (double time);
- void write_pass_finished (double when);
+ void write_pass_finished (double when, double thinning_factor=0.0);
void set_in_write_pass (bool, bool add_point = false, double when = 0.0);
bool in_write_pass () const;
/** Emitted when our interpolation style changes */
PBD::Signal1<void, InterpolationStyle> InterpolationChanged;
- static void set_thinning_factor (double d);
- static double thinning_factor() { return _thinning_factor; }
-
bool operator!= (ControlList const &) const;
void invalidate_insert_iterator ();
Curve* _curve;
- static double _thinning_factor;
-
private:
iterator most_recent_insert_iterator;
double insert_position;
return a->when < b->when;
}
-/* this has no units but corresponds to the area of a rectangle
- computed between three points in the list. If the area is
- large, it indicates significant non-linearity between the
- points.
-
- during automation recording we thin the recorded points
- using this value. if a point is sufficiently co-linear
- with its neighbours (as defined by the area of the rectangle
- formed by three of them), we will not include it in the
- ControlList. a smaller value will exclude less points,
- a larger value will exclude more points, so it effectively
- measures the amount of thinning to be done.
-*/
-
-double ControlList::_thinning_factor = 20.0;
-
ControlList::ControlList (const Parameter& id)
: _parameter(id)
, _interpolation(id.toggled() ? Discrete : Linear)
};
void
-ControlList::thin ()
+ControlList::thin (double thinning_factor)
{
+ if (thinning_factor == 0.0) {
+ return;
+ }
+
bool changed = false;
{
(prev->when * (cur->value - prevprev->value)) +
(cur->when * (prevprev->value - prev->value)));
- if (area < _thinning_factor) {
+ if (area < thinning_factor) {
iterator tmp = pprev;
/* pprev will change to current
}
void
-ControlList::write_pass_finished (double /*when*/)
+ControlList::write_pass_finished (double /*when*/, double thinning_factor)
{
DEBUG_TRACE (DEBUG::ControlList, "write pass finished\n");
if (did_write_during_pass) {
- thin ();
+ thin (thinning_factor);
did_write_during_pass = false;
}
new_write_pass = true;
InterpolationChanged (s); /* EMIT SIGNAL */
}
-void
-ControlList::set_thinning_factor (double v)
-{
- _thinning_factor = v;
-}
-
bool
ControlList::operator!= (ControlList const & other) const
{
projects / ardour.git / commitdiff