gstreamer/libs/gst/controller/gstinterpolationcontrolsource.c
Stefan Sauer 9a30399e4f interpolationcontrolsource: fix write over the array size
The '++' got incidentially added during the refactoring in
2fe3939ce7.
2015-10-01 22:12:50 +02:00

757 lines
21 KiB
C

/* GStreamer
*
* Copyright (C) 2007,2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
*
* gstinterpolationcontrolsource.c: Control source that provides several
* interpolation methods
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:gstinterpolationcontrolsource
* @short_description: interpolation control source
*
* #GstInterpolationControlSource is a #GstControlSource, that interpolates values between user-given
* control points. It supports several interpolation modes and property types.
*
* To use #GstInterpolationControlSource get a new instance by calling
* gst_interpolation_control_source_new(), bind it to a #GParamSpec and set some
* control points by calling gst_timed_value_control_source_set().
*
* All functions are MT-safe.
*
*/
#include <glib-object.h>
#include <gst/gst.h>
#include "gstinterpolationcontrolsource.h"
#include "gst/glib-compat-private.h"
#include "gst/math-compat.h"
#define GST_CAT_DEFAULT controller_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
/* helper functions */
static inline gboolean
_get_nearest_control_points (GstTimedValueControlSource * self,
GstClockTime ts, GstControlPoint ** cp1, GstControlPoint ** cp2)
{
GSequenceIter *iter;
iter = gst_timed_value_control_source_find_control_point_iter (self, ts);
if (iter) {
*cp1 = g_sequence_get (iter);
iter = g_sequence_iter_next (iter);
if (iter && !g_sequence_iter_is_end (iter)) {
*cp2 = g_sequence_get (iter);
} else {
*cp2 = NULL;
}
return TRUE;
}
return FALSE;
}
static inline void
_get_nearest_control_points2 (GstTimedValueControlSource * self,
GstClockTime ts, GstControlPoint ** cp1, GstControlPoint ** cp2,
GstClockTime * next_ts)
{
GSequenceIter *iter1, *iter2 = NULL;
*cp1 = *cp2 = NULL;
iter1 = gst_timed_value_control_source_find_control_point_iter (self, ts);
if (iter1) {
*cp1 = g_sequence_get (iter1);
iter2 = g_sequence_iter_next (iter1);
} else {
if (G_LIKELY (self->values)) {
/* all values in the control point list come after the given timestamp */
iter2 = g_sequence_get_begin_iter (self->values);
/* why this? if !cp1 we don't interpolate anyway
* if we can eliminate this, we can also use _get_nearest_control_points()
* here, is this just to set next_ts? */
} else {
/* no values */
iter2 = NULL;
}
}
if (iter2 && !g_sequence_iter_is_end (iter2)) {
*cp2 = g_sequence_get (iter2);
*next_ts = (*cp2)->timestamp;
} else {
*next_ts = GST_CLOCK_TIME_NONE;
}
}
/* steps-like (no-)interpolation, default */
/* just returns the value for the most recent key-frame */
static inline gdouble
_interpolate_none (GstTimedValueControlSource * self, GstControlPoint * cp)
{
return cp->value;
}
static gboolean
interpolate_none_get (GstTimedValueControlSource * self, GstClockTime timestamp,
gdouble * value)
{
gboolean ret = FALSE;
GSequenceIter *iter;
GstControlPoint *cp;
g_mutex_lock (&self->lock);
iter =
gst_timed_value_control_source_find_control_point_iter (self, timestamp);
if (iter) {
cp = g_sequence_get (iter);
*value = _interpolate_none (self, cp);
ret = TRUE;
}
g_mutex_unlock (&self->lock);
return ret;
}
static gboolean
interpolate_none_get_value_array (GstTimedValueControlSource * self,
GstClockTime timestamp, GstClockTime interval, guint n_values,
gdouble * values)
{
gboolean ret = FALSE;
guint i;
GstClockTime ts = timestamp;
GstClockTime next_ts = 0;
GstControlPoint *cp1 = NULL, *cp2 = NULL;
g_mutex_lock (&self->lock);
for (i = 0; i < n_values; i++) {
GST_LOG ("values[%3d] : ts=%" GST_TIME_FORMAT ", next_ts=%" GST_TIME_FORMAT,
i, GST_TIME_ARGS (ts), GST_TIME_ARGS (next_ts));
if (ts >= next_ts) {
_get_nearest_control_points2 (self, ts, &cp1, &cp2, &next_ts);
}
if (cp1) {
*values = _interpolate_none (self, cp1);
ret = TRUE;
GST_LOG ("values[%3d]=%lf", i, *values);
} else {
*values = NAN;
GST_LOG ("values[%3d]=-", i);
}
ts += interval;
values++;
}
g_mutex_unlock (&self->lock);
return ret;
}
/* linear interpolation */
/* smoothes inbetween values */
static inline gdouble
_interpolate_linear (GstClockTime timestamp1, gdouble value1,
GstClockTime timestamp2, gdouble value2, GstClockTime timestamp)
{
if (GST_CLOCK_TIME_IS_VALID (timestamp2)) {
gdouble slope;
slope =
(value2 - value1) / gst_guint64_to_gdouble (timestamp2 - timestamp1);
return value1 + (gst_guint64_to_gdouble (timestamp - timestamp1) * slope);
} else {
return value1;
}
}
static gboolean
interpolate_linear_get (GstTimedValueControlSource * self,
GstClockTime timestamp, gdouble * value)
{
gboolean ret = FALSE;
GstControlPoint *cp1, *cp2;
g_mutex_lock (&self->lock);
if (_get_nearest_control_points (self, timestamp, &cp1, &cp2)) {
*value = _interpolate_linear (cp1->timestamp, cp1->value,
(cp2 ? cp2->timestamp : GST_CLOCK_TIME_NONE),
(cp2 ? cp2->value : 0.0), timestamp);
ret = TRUE;
}
g_mutex_unlock (&self->lock);
return ret;
}
static gboolean
interpolate_linear_get_value_array (GstTimedValueControlSource * self,
GstClockTime timestamp, GstClockTime interval, guint n_values,
gdouble * values)
{
gboolean ret = FALSE;
guint i;
GstClockTime ts = timestamp;
GstClockTime next_ts = 0;
GstControlPoint *cp1 = NULL, *cp2 = NULL;
g_mutex_lock (&self->lock);
for (i = 0; i < n_values; i++) {
GST_LOG ("values[%3d] : ts=%" GST_TIME_FORMAT ", next_ts=%" GST_TIME_FORMAT,
i, GST_TIME_ARGS (ts), GST_TIME_ARGS (next_ts));
if (ts >= next_ts) {
_get_nearest_control_points2 (self, ts, &cp1, &cp2, &next_ts);
}
if (cp1) {
*values = _interpolate_linear (cp1->timestamp, cp1->value,
(cp2 ? cp2->timestamp : GST_CLOCK_TIME_NONE),
(cp2 ? cp2->value : 0.0), ts);
ret = TRUE;
GST_LOG ("values[%3d]=%lf", i, *values);
} else {
*values = NAN;
GST_LOG ("values[%3d]=-", i);
}
ts += interval;
values++;
}
g_mutex_unlock (&self->lock);
return ret;
}
/* cubic interpolation */
/* The following functions implement a natural cubic spline interpolator.
* For details look at http://en.wikipedia.org/wiki/Spline_interpolation
*
* Instead of using a real matrix with n^2 elements for the linear system
* of equations we use three arrays o, p, q to hold the tridiagonal matrix
* as following to save memory:
*
* p[0] q[0] 0 0 0
* o[1] p[1] q[1] 0 0
* 0 o[2] p[2] q[2] .
* . . . . .
*/
static void
_interpolate_cubic_update_cache (GstTimedValueControlSource * self)
{
gint i, n = self->nvalues;
gdouble *o = g_new0 (gdouble, n);
gdouble *p = g_new0 (gdouble, n);
gdouble *q = g_new0 (gdouble, n);
gdouble *h = g_new0 (gdouble, n);
gdouble *b = g_new0 (gdouble, n);
gdouble *z = g_new0 (gdouble, n);
GSequenceIter *iter;
GstControlPoint *cp;
GstClockTime x, x_next;
gdouble y_prev, y, y_next;
/* Fill linear system of equations */
iter = g_sequence_get_begin_iter (self->values);
cp = g_sequence_get (iter);
x = cp->timestamp;
y = cp->value;
p[0] = 1.0;
iter = g_sequence_iter_next (iter);
cp = g_sequence_get (iter);
x_next = cp->timestamp;
y_next = cp->value;
h[0] = gst_guint64_to_gdouble (x_next - x);
for (i = 1; i < n - 1; i++) {
/* Shuffle x and y values */
y_prev = y;
x = x_next;
y = y_next;
iter = g_sequence_iter_next (iter);
cp = g_sequence_get (iter);
x_next = cp->timestamp;
y_next = cp->value;
h[i] = gst_guint64_to_gdouble (x_next - x);
o[i] = h[i - 1];
p[i] = 2.0 * (h[i - 1] + h[i]);
q[i] = h[i];
b[i] = (y_next - y) / h[i] - (y - y_prev) / h[i - 1];
}
p[n - 1] = 1.0;
/* Use Gauss elimination to set everything below the diagonal to zero */
for (i = 1; i < n - 1; i++) {
gdouble a = o[i] / p[i - 1];
p[i] -= a * q[i - 1];
b[i] -= a * b[i - 1];
}
/* Solve everything else from bottom to top */
for (i = n - 2; i > 0; i--)
z[i] = (b[i] - q[i] * z[i + 1]) / p[i];
/* Save cache next in the GstControlPoint */
iter = g_sequence_get_begin_iter (self->values);
for (i = 0; i < n; i++) {
cp = g_sequence_get (iter);
cp->cache.cubic.h = h[i];
cp->cache.cubic.z = z[i];
iter = g_sequence_iter_next (iter);
}
/* Free our temporary arrays */
g_free (o);
g_free (p);
g_free (q);
g_free (h);
g_free (b);
g_free (z);
}
static inline gdouble
_interpolate_cubic (GstTimedValueControlSource * self, GstControlPoint * cp1,
gdouble value1, GstControlPoint * cp2, gdouble value2,
GstClockTime timestamp)
{
if (!self->valid_cache) {
_interpolate_cubic_update_cache (self);
self->valid_cache = TRUE;
}
if (cp2) {
gdouble diff1, diff2;
gdouble out;
diff1 = gst_guint64_to_gdouble (timestamp - cp1->timestamp);
diff2 = gst_guint64_to_gdouble (cp2->timestamp - timestamp);
out =
(cp2->cache.cubic.z * diff1 * diff1 * diff1 +
cp1->cache.cubic.z * diff2 * diff2 * diff2) / cp1->cache.cubic.h;
out +=
(value2 / cp1->cache.cubic.h -
cp1->cache.cubic.h * cp2->cache.cubic.z) * diff1;
out +=
(value1 / cp1->cache.cubic.h -
cp1->cache.cubic.h * cp1->cache.cubic.z) * diff2;
return out;
} else {
return value1;
}
}
static gboolean
interpolate_cubic_get (GstTimedValueControlSource * self,
GstClockTime timestamp, gdouble * value)
{
gboolean ret = FALSE;
GstControlPoint *cp1, *cp2 = NULL;
if (self->nvalues <= 2)
return interpolate_linear_get (self, timestamp, value);
g_mutex_lock (&self->lock);
if (_get_nearest_control_points (self, timestamp, &cp1, &cp2)) {
*value = _interpolate_cubic (self, cp1, cp1->value, cp2,
(cp2 ? cp2->value : 0.0), timestamp);
ret = TRUE;
}
g_mutex_unlock (&self->lock);
return ret;
}
static gboolean
interpolate_cubic_get_value_array (GstTimedValueControlSource * self,
GstClockTime timestamp, GstClockTime interval, guint n_values,
gdouble * values)
{
gboolean ret = FALSE;
guint i;
GstClockTime ts = timestamp;
GstClockTime next_ts = 0;
GstControlPoint *cp1 = NULL, *cp2 = NULL;
if (self->nvalues <= 2)
return interpolate_linear_get_value_array (self, timestamp, interval,
n_values, values);
g_mutex_lock (&self->lock);
for (i = 0; i < n_values; i++) {
GST_LOG ("values[%3d] : ts=%" GST_TIME_FORMAT ", next_ts=%" GST_TIME_FORMAT,
i, GST_TIME_ARGS (ts), GST_TIME_ARGS (next_ts));
if (ts >= next_ts) {
_get_nearest_control_points2 (self, ts, &cp1, &cp2, &next_ts);
}
if (cp1) {
*values = _interpolate_cubic (self, cp1, cp1->value, cp2,
(cp2 ? cp2->value : 0.0), ts);
ret = TRUE;
GST_LOG ("values[%3d]=%lf", i, *values);
} else {
*values = NAN;
GST_LOG ("values[%3d]=-", i);
}
ts += interval;
values++;
}
g_mutex_unlock (&self->lock);
return ret;
}
/* monotonic cubic interpolation */
/* the following functions implement monotonic cubic spline interpolation.
* For details: http://en.wikipedia.org/wiki/Monotone_cubic_interpolation
*
* In contrast to the previous cubic mode, the values won't overshoot.
*/
static void
_interpolate_cubic_mono_update_cache (GstTimedValueControlSource * self)
{
gint i, n = self->nvalues;
gdouble *dxs = g_new0 (gdouble, n);
gdouble *dys = g_new0 (gdouble, n);
gdouble *ms = g_new0 (gdouble, n);
gdouble *c1s = g_new0 (gdouble, n);
GSequenceIter *iter;
GstControlPoint *cp;
GstClockTime x, x_next, dx;
gdouble y, y_next, dy;
/* Get consecutive differences and slopes */
iter = g_sequence_get_begin_iter (self->values);
cp = g_sequence_get (iter);
x_next = cp->timestamp;
y_next = cp->value;
for (i = 0; i < n - 1; i++) {
x = x_next;
y = y_next;
iter = g_sequence_iter_next (iter);
cp = g_sequence_get (iter);
x_next = cp->timestamp;
y_next = cp->value;
dx = gst_guint64_to_gdouble (x_next - x);
dy = y_next - y;
dxs[i] = dx;
dys[i] = dy;
ms[i] = dy / dx;
}
/* Get degree-1 coefficients */
c1s[0] = ms[0];
for (i = 1; i < n; i++) {
gdouble m = ms[i - 1];
gdouble m_next = ms[i];
if (m * m_next <= 0) {
c1s[i] = 0.0;
} else {
gdouble dx_next, dx_sum;
dx = dxs[i], dx_next = dxs[i + 1], dx_sum = dx + dx_next;
c1s[i] = 3.0 * dx_sum / ((dx_sum + dx_next) / m + (dx_sum + dx) / m_next);
}
}
c1s[n - 1] = ms[n - 1];
/* Get degree-2 and degree-3 coefficients */
iter = g_sequence_get_begin_iter (self->values);
for (i = 0; i < n - 1; i++) {
gdouble c1, m, inv_dx, common;
cp = g_sequence_get (iter);
c1 = c1s[i];
m = ms[i];
inv_dx = 1.0 / dxs[i];
common = c1 + c1s[i + 1] - m - m;
cp->cache.cubic_mono.c1s = c1;
cp->cache.cubic_mono.c2s = (m - c1 - common) * inv_dx;
cp->cache.cubic_mono.c3s = common * inv_dx * inv_dx;
iter = g_sequence_iter_next (iter);
}
/* Free our temporary arrays */
g_free (dxs);
g_free (dys);
g_free (ms);
g_free (c1s);
}
static inline gdouble
_interpolate_cubic_mono (GstTimedValueControlSource * self,
GstControlPoint * cp1, gdouble value1, GstControlPoint * cp2,
gdouble value2, GstClockTime timestamp)
{
if (!self->valid_cache) {
_interpolate_cubic_mono_update_cache (self);
self->valid_cache = TRUE;
}
if (cp2) {
gdouble diff = gst_guint64_to_gdouble (timestamp - cp1->timestamp);
gdouble diff2 = diff * diff;
gdouble out;
out = value1 + cp1->cache.cubic_mono.c1s * diff;
out += cp1->cache.cubic_mono.c2s * diff2;
out += cp1->cache.cubic_mono.c3s * diff * diff2;
return out;
} else {
return value1;
}
}
static gboolean
interpolate_cubic_mono_get (GstTimedValueControlSource * self,
GstClockTime timestamp, gdouble * value)
{
gboolean ret = FALSE;
GstControlPoint *cp1, *cp2 = NULL;
if (self->nvalues <= 2)
return interpolate_linear_get (self, timestamp, value);
g_mutex_lock (&self->lock);
if (_get_nearest_control_points (self, timestamp, &cp1, &cp2)) {
*value = _interpolate_cubic_mono (self, cp1, cp1->value, cp2,
(cp2 ? cp2->value : 0.0), timestamp);
ret = TRUE;
}
g_mutex_unlock (&self->lock);
return ret;
}
static gboolean
interpolate_cubic_mono_get_value_array (GstTimedValueControlSource * self,
GstClockTime timestamp, GstClockTime interval, guint n_values,
gdouble * values)
{
gboolean ret = FALSE;
guint i;
GstClockTime ts = timestamp;
GstClockTime next_ts = 0;
GstControlPoint *cp1 = NULL, *cp2 = NULL;
if (self->nvalues <= 2)
return interpolate_linear_get_value_array (self, timestamp, interval,
n_values, values);
g_mutex_lock (&self->lock);
for (i = 0; i < n_values; i++) {
GST_LOG ("values[%3d] : ts=%" GST_TIME_FORMAT ", next_ts=%" GST_TIME_FORMAT,
i, GST_TIME_ARGS (ts), GST_TIME_ARGS (next_ts));
if (ts >= next_ts) {
_get_nearest_control_points2 (self, ts, &cp1, &cp2, &next_ts);
}
if (cp1) {
*values = _interpolate_cubic_mono (self, cp1, cp1->value, cp2,
(cp2 ? cp2->value : 0.0), ts);
ret = TRUE;
GST_LOG ("values[%3d]=%lf", i, *values);
} else {
*values = NAN;
GST_LOG ("values[%3d]=-", i);
}
ts += interval;
values++;
}
g_mutex_unlock (&self->lock);
return ret;
}
static struct
{
GstControlSourceGetValue get;
GstControlSourceGetValueArray get_value_array;
} interpolation_modes[] = {
{
(GstControlSourceGetValue) interpolate_none_get,
(GstControlSourceGetValueArray) interpolate_none_get_value_array}, {
(GstControlSourceGetValue) interpolate_linear_get,
(GstControlSourceGetValueArray) interpolate_linear_get_value_array}, {
(GstControlSourceGetValue) interpolate_cubic_get,
(GstControlSourceGetValueArray) interpolate_cubic_get_value_array}, {
(GstControlSourceGetValue) interpolate_cubic_mono_get,
(GstControlSourceGetValueArray)
interpolate_cubic_mono_get_value_array}};
static const guint num_interpolation_modes = G_N_ELEMENTS (interpolation_modes);
enum
{
PROP_MODE = 1
};
GType
gst_interpolation_mode_get_type (void)
{
static gsize gtype = 0;
static const GEnumValue values[] = {
{GST_INTERPOLATION_MODE_NONE, "GST_INTERPOLATION_MODE_NONE", "none"},
{GST_INTERPOLATION_MODE_LINEAR, "GST_INTERPOLATION_MODE_LINEAR", "linear"},
{GST_INTERPOLATION_MODE_CUBIC, "GST_INTERPOLATION_MODE_CUBIC", "cubic"},
{GST_INTERPOLATION_MODE_CUBIC_MONO, "GST_INTERPOLATION_MODE_CUBIC_MONO",
"cubic-mono"},
{0, NULL, NULL}
};
if (g_once_init_enter (&gtype)) {
GType tmp = g_enum_register_static ("GstInterpolationMode", values);
g_once_init_leave (&gtype, tmp);
}
return (GType) gtype;
}
#define _do_init \
GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "interpolation control source", 0, \
"timeline value interpolating control source")
G_DEFINE_TYPE_WITH_CODE (GstInterpolationControlSource,
gst_interpolation_control_source, GST_TYPE_TIMED_VALUE_CONTROL_SOURCE,
_do_init);
struct _GstInterpolationControlSourcePrivate
{
GstInterpolationMode interpolation_mode;
};
/**
* gst_interpolation_control_source_new:
*
* This returns a new, unbound #GstInterpolationControlSource.
*
* Returns: (transfer full): a new, unbound #GstInterpolationControlSource.
*/
GstControlSource *
gst_interpolation_control_source_new (void)
{
return g_object_newv (GST_TYPE_INTERPOLATION_CONTROL_SOURCE, 0, NULL);
}
static gboolean
gst_interpolation_control_source_set_interpolation_mode
(GstInterpolationControlSource * self, GstInterpolationMode mode)
{
GstControlSource *csource = GST_CONTROL_SOURCE (self);
if (mode >= num_interpolation_modes || (int) mode < 0) {
GST_WARNING ("interpolation mode %d invalid or not implemented yet", mode);
return FALSE;
}
GST_TIMED_VALUE_CONTROL_SOURCE_LOCK (self);
csource->get_value = interpolation_modes[mode].get;
csource->get_value_array = interpolation_modes[mode].get_value_array;
gst_timed_value_control_invalidate_cache ((GstTimedValueControlSource *)
csource);
self->priv->interpolation_mode = mode;
GST_TIMED_VALUE_CONTROL_SOURCE_UNLOCK (self);
return TRUE;
}
static void
gst_interpolation_control_source_init (GstInterpolationControlSource * self)
{
self->priv =
G_TYPE_INSTANCE_GET_PRIVATE (self, GST_TYPE_INTERPOLATION_CONTROL_SOURCE,
GstInterpolationControlSourcePrivate);
gst_interpolation_control_source_set_interpolation_mode (self,
GST_INTERPOLATION_MODE_NONE);
}
static void
gst_interpolation_control_source_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstInterpolationControlSource *self =
GST_INTERPOLATION_CONTROL_SOURCE (object);
switch (prop_id) {
case PROP_MODE:
gst_interpolation_control_source_set_interpolation_mode (self,
(GstInterpolationMode) g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_interpolation_control_source_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstInterpolationControlSource *self =
GST_INTERPOLATION_CONTROL_SOURCE (object);
switch (prop_id) {
case PROP_MODE:
g_value_set_enum (value, self->priv->interpolation_mode);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_interpolation_control_source_class_init (GstInterpolationControlSourceClass
* klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
//GstControlSourceClass *csource_class = GST_CONTROL_SOURCE_CLASS (klass);
g_type_class_add_private (klass,
sizeof (GstInterpolationControlSourcePrivate));
gobject_class->set_property = gst_interpolation_control_source_set_property;
gobject_class->get_property = gst_interpolation_control_source_get_property;
g_object_class_install_property (gobject_class, PROP_MODE,
g_param_spec_enum ("mode", "Mode", "Interpolation mode",
GST_TYPE_INTERPOLATION_MODE, GST_INTERPOLATION_MODE_NONE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}