--- /dev/null
+/* GStreamer
+ *
+ * Copyright (C) 2007 Sebastian Dröge <slomo@circular-chaos.org>
+ *
+ * gstlfocontrolsource.c: Control source that provides some periodic waveforms
+ * as control values.
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:gstlfocontrolsource
+ * @short_description: LFO control source
+ *
+ * #GstLFOControlSource is a #GstControlSource, that provides several periodic waveforms
+ * as control values. It supports all fundamental, numeric GValue types as property.
+ *
+ * To use #GstLFOControlSource get a new instance by calling gst_lfo_control_source_new(),
+ * bind it to a #GParamSpec and set the relevant properties or use
+ * gst_lfo_control_source_set_waveform.
+ *
+ * All functions are MT-safe.
+ *
+ */
+
+#include <glib-object.h>
+#include <gst/gst.h>
+
+#include "gstcontrolsource.h"
+#include "gstlfocontrolsource.h"
+#include "gstlfocontrolsourceprivate.h"
+
+#include "math.h"
+
+/* FIXME: as % in C is not the modulo operator we need here for
+ * negative numbers implement our own. Are there better ways? */
+static inline GstClockTime
+_calculate_pos (GstClockTime timestamp, GstClockTime timeshift,
+ GstClockTime period)
+{
+ while (timestamp < timeshift)
+ timestamp += period;
+
+ timestamp -= timeshift;
+
+ return timestamp % period;
+}
+
+#define DEFINE_SINE(type,round) \
+\
+static inline g##type \
+_sine_get_##type (GstLFOControlSource *self, GstClockTime timestamp) \
+{ \
+ gdouble ret; \
+ g##type max = g_value_get_##type (&self->priv->maximum_value); \
+ g##type min = g_value_get_##type (&self->priv->minimum_value); \
+ gdouble amp = g_value_get_##type (&self->priv->amplitude); \
+ gdouble off = g_value_get_##type (&self->priv->offset); \
+ GstClockTime pos = _calculate_pos (timestamp, self->priv->timeshift, self->priv->period); \
+ \
+ ret = sin (2.0 * M_PI * (self->priv->frequency / GST_SECOND) * pos); \
+ ret *= amp; \
+ ret += off; \
+ \
+ if (round) \
+ ret += 0.5; \
+ \
+ return (g##type) CLAMP (ret, min, max); \
+} \
+\
+static gboolean \
+waveform_sine_get_##type (GstLFOControlSource *self, GstClockTime timestamp, \
+ GValue *value) \
+{ \
+ g##type ret; \
+ g_mutex_lock (self->lock); \
+ ret = _sine_get_##type (self, timestamp); \
+ g_value_set_##type (value, ret); \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+} \
+\
+static gboolean \
+waveform_sine_get_##type##_value_array (GstLFOControlSource *self, \
+ GstClockTime timestamp, GstValueArray * value_array) \
+{ \
+ gint i; \
+ GstClockTime ts = timestamp; \
+ g##type *values = (g##type *) value_array->values; \
+ \
+ g_mutex_lock (self->lock); \
+ for(i = 0; i < value_array->nbsamples; i++) { \
+ *values = _sine_get_##type (self, ts); \
+ ts += value_array->sample_interval; \
+ values++; \
+ } \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+}
+
+DEFINE_SINE (int, TRUE);
+DEFINE_SINE (uint, TRUE);
+DEFINE_SINE (long, TRUE);
+
+DEFINE_SINE (ulong, TRUE);
+DEFINE_SINE (int64, TRUE);
+DEFINE_SINE (uint64, TRUE);
+DEFINE_SINE (float, FALSE);
+DEFINE_SINE (double, FALSE);
+
+static GstWaveformImplementation waveform_sine = {
+ (GstControlSourceGetValue) waveform_sine_get_int,
+ (GstControlSourceGetValueArray) waveform_sine_get_int_value_array,
+ (GstControlSourceGetValue) waveform_sine_get_uint,
+ (GstControlSourceGetValueArray) waveform_sine_get_uint_value_array,
+ (GstControlSourceGetValue) waveform_sine_get_long,
+ (GstControlSourceGetValueArray) waveform_sine_get_long_value_array,
+ (GstControlSourceGetValue) waveform_sine_get_ulong,
+ (GstControlSourceGetValueArray) waveform_sine_get_ulong_value_array,
+ (GstControlSourceGetValue) waveform_sine_get_int64,
+ (GstControlSourceGetValueArray) waveform_sine_get_int64_value_array,
+ (GstControlSourceGetValue) waveform_sine_get_uint64,
+ (GstControlSourceGetValueArray) waveform_sine_get_uint64_value_array,
+ (GstControlSourceGetValue) waveform_sine_get_float,
+ (GstControlSourceGetValueArray) waveform_sine_get_float_value_array,
+ (GstControlSourceGetValue) waveform_sine_get_double,
+ (GstControlSourceGetValueArray) waveform_sine_get_double_value_array
+};
+
+#define DEFINE_SQUARE(type,round) \
+\
+static inline g##type \
+_square_get_##type (GstLFOControlSource *self, GstClockTime timestamp) \
+{ \
+ g##type max = g_value_get_##type (&self->priv->maximum_value); \
+ g##type min = g_value_get_##type (&self->priv->minimum_value); \
+ gdouble amp = g_value_get_##type (&self->priv->amplitude); \
+ gdouble off = g_value_get_##type (&self->priv->offset); \
+ GstClockTime period = self->priv->period; \
+ GstClockTime pos = _calculate_pos (timestamp, self->priv->timeshift, period); \
+ gdouble ret; \
+ \
+ if (pos >= period / 2) \
+ ret = amp; \
+ else \
+ ret = - amp; \
+ \
+ ret += off; \
+ \
+ if (round) \
+ ret += 0.5; \
+ \
+ return (g##type) CLAMP (ret, min, max); \
+} \
+\
+static gboolean \
+waveform_square_get_##type (GstLFOControlSource *self, GstClockTime timestamp, \
+ GValue *value) \
+{ \
+ g##type ret; \
+ g_mutex_lock (self->lock); \
+ ret = _square_get_##type (self, timestamp); \
+ g_value_set_##type (value, ret); \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+} \
+\
+static gboolean \
+waveform_square_get_##type##_value_array (GstLFOControlSource *self, \
+ GstClockTime timestamp, GstValueArray * value_array) \
+{ \
+ gint i; \
+ GstClockTime ts = timestamp; \
+ g##type *values = (g##type *) value_array->values; \
+ \
+ g_mutex_lock (self->lock); \
+ for(i = 0; i < value_array->nbsamples; i++) { \
+ *values = _square_get_##type (self, ts); \
+ ts += value_array->sample_interval; \
+ values++; \
+ } \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+}
+
+DEFINE_SQUARE (int, TRUE);
+
+DEFINE_SQUARE (uint, TRUE);
+DEFINE_SQUARE (long, TRUE);
+
+DEFINE_SQUARE (ulong, TRUE);
+DEFINE_SQUARE (int64, TRUE);
+DEFINE_SQUARE (uint64, TRUE);
+DEFINE_SQUARE (float, FALSE);
+DEFINE_SQUARE (double, FALSE);
+
+static GstWaveformImplementation waveform_square = {
+ (GstControlSourceGetValue) waveform_square_get_int,
+ (GstControlSourceGetValueArray) waveform_square_get_int_value_array,
+ (GstControlSourceGetValue) waveform_square_get_uint,
+ (GstControlSourceGetValueArray) waveform_square_get_uint_value_array,
+ (GstControlSourceGetValue) waveform_square_get_long,
+ (GstControlSourceGetValueArray) waveform_square_get_long_value_array,
+ (GstControlSourceGetValue) waveform_square_get_ulong,
+ (GstControlSourceGetValueArray) waveform_square_get_ulong_value_array,
+ (GstControlSourceGetValue) waveform_square_get_int64,
+ (GstControlSourceGetValueArray) waveform_square_get_int64_value_array,
+ (GstControlSourceGetValue) waveform_square_get_uint64,
+ (GstControlSourceGetValueArray) waveform_square_get_uint64_value_array,
+ (GstControlSourceGetValue) waveform_square_get_float,
+ (GstControlSourceGetValueArray) waveform_square_get_float_value_array,
+ (GstControlSourceGetValue) waveform_square_get_double,
+ (GstControlSourceGetValueArray) waveform_square_get_double_value_array
+};
+
+#define DEFINE_SAW(type,round) \
+\
+static inline g##type \
+_saw_get_##type (GstLFOControlSource *self, GstClockTime timestamp) \
+{ \
+ g##type max = g_value_get_##type (&self->priv->maximum_value); \
+ g##type min = g_value_get_##type (&self->priv->minimum_value); \
+ gdouble amp = g_value_get_##type (&self->priv->amplitude); \
+ gdouble off = g_value_get_##type (&self->priv->offset); \
+ GstClockTime period = self->priv->period; \
+ GstClockTime pos = _calculate_pos (timestamp, self->priv->timeshift, period); \
+ gdouble ret; \
+ \
+ ret = - ((pos - period / 2.0) * ((2.0 * amp) / period));\
+ \
+ ret += off; \
+ \
+ if (round) \
+ ret += 0.5; \
+ \
+ return (g##type) CLAMP (ret, min, max); \
+} \
+\
+static gboolean \
+waveform_saw_get_##type (GstLFOControlSource *self, GstClockTime timestamp, \
+ GValue *value) \
+{ \
+ g##type ret; \
+ g_mutex_lock (self->lock); \
+ ret = _saw_get_##type (self, timestamp); \
+ g_value_set_##type (value, ret); \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+} \
+\
+static gboolean \
+waveform_saw_get_##type##_value_array (GstLFOControlSource *self, \
+ GstClockTime timestamp, GstValueArray * value_array) \
+{ \
+ gint i; \
+ GstClockTime ts = timestamp; \
+ g##type *values = (g##type *) value_array->values; \
+ \
+ g_mutex_lock (self->lock); \
+ for(i = 0; i < value_array->nbsamples; i++) { \
+ *values = _saw_get_##type (self, ts); \
+ ts += value_array->sample_interval; \
+ values++; \
+ } \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+}
+
+DEFINE_SAW (int, TRUE);
+
+DEFINE_SAW (uint, TRUE);
+DEFINE_SAW (long, TRUE);
+
+DEFINE_SAW (ulong, TRUE);
+DEFINE_SAW (int64, TRUE);
+DEFINE_SAW (uint64, TRUE);
+DEFINE_SAW (float, FALSE);
+DEFINE_SAW (double, FALSE);
+
+static GstWaveformImplementation waveform_saw = {
+ (GstControlSourceGetValue) waveform_saw_get_int,
+ (GstControlSourceGetValueArray) waveform_saw_get_int_value_array,
+ (GstControlSourceGetValue) waveform_saw_get_uint,
+ (GstControlSourceGetValueArray) waveform_saw_get_uint_value_array,
+ (GstControlSourceGetValue) waveform_saw_get_long,
+ (GstControlSourceGetValueArray) waveform_saw_get_long_value_array,
+ (GstControlSourceGetValue) waveform_saw_get_ulong,
+ (GstControlSourceGetValueArray) waveform_saw_get_ulong_value_array,
+ (GstControlSourceGetValue) waveform_saw_get_int64,
+ (GstControlSourceGetValueArray) waveform_saw_get_int64_value_array,
+ (GstControlSourceGetValue) waveform_saw_get_uint64,
+ (GstControlSourceGetValueArray) waveform_saw_get_uint64_value_array,
+ (GstControlSourceGetValue) waveform_saw_get_float,
+ (GstControlSourceGetValueArray) waveform_saw_get_float_value_array,
+ (GstControlSourceGetValue) waveform_saw_get_double,
+ (GstControlSourceGetValueArray) waveform_saw_get_double_value_array
+};
+
+#define DEFINE_RSAW(type,round) \
+\
+static inline g##type \
+_rsaw_get_##type (GstLFOControlSource *self, GstClockTime timestamp) \
+{ \
+ g##type max = g_value_get_##type (&self->priv->maximum_value); \
+ g##type min = g_value_get_##type (&self->priv->minimum_value); \
+ gdouble amp = g_value_get_##type (&self->priv->amplitude); \
+ gdouble off = g_value_get_##type (&self->priv->offset); \
+ GstClockTime period = self->priv->period; \
+ GstClockTime pos = _calculate_pos (timestamp, self->priv->timeshift, period); \
+ gdouble ret; \
+ \
+ ret = ((pos - period / 2.0) * ((2.0 * amp) / period));\
+ \
+ ret += off; \
+ \
+ if (round) \
+ ret += 0.5; \
+ \
+ return (g##type) CLAMP (ret, min, max); \
+} \
+\
+static gboolean \
+waveform_rsaw_get_##type (GstLFOControlSource *self, GstClockTime timestamp, \
+ GValue *value) \
+{ \
+ g##type ret; \
+ g_mutex_lock (self->lock); \
+ ret = _rsaw_get_##type (self, timestamp); \
+ g_value_set_##type (value, ret); \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+} \
+\
+static gboolean \
+waveform_rsaw_get_##type##_value_array (GstLFOControlSource *self, \
+ GstClockTime timestamp, GstValueArray * value_array) \
+{ \
+ gint i; \
+ GstClockTime ts = timestamp; \
+ g##type *values = (g##type *) value_array->values; \
+ \
+ g_mutex_lock (self->lock); \
+ for(i = 0; i < value_array->nbsamples; i++) { \
+ *values = _rsaw_get_##type (self, ts); \
+ ts += value_array->sample_interval; \
+ values++; \
+ } \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+}
+
+DEFINE_RSAW (int, TRUE);
+
+DEFINE_RSAW (uint, TRUE);
+DEFINE_RSAW (long, TRUE);
+
+DEFINE_RSAW (ulong, TRUE);
+DEFINE_RSAW (int64, TRUE);
+DEFINE_RSAW (uint64, TRUE);
+DEFINE_RSAW (float, FALSE);
+DEFINE_RSAW (double, FALSE);
+
+static GstWaveformImplementation waveform_rsaw = {
+ (GstControlSourceGetValue) waveform_rsaw_get_int,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_int_value_array,
+ (GstControlSourceGetValue) waveform_rsaw_get_uint,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_uint_value_array,
+ (GstControlSourceGetValue) waveform_rsaw_get_long,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_long_value_array,
+ (GstControlSourceGetValue) waveform_rsaw_get_ulong,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_ulong_value_array,
+ (GstControlSourceGetValue) waveform_rsaw_get_int64,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_int64_value_array,
+ (GstControlSourceGetValue) waveform_rsaw_get_uint64,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_uint64_value_array,
+ (GstControlSourceGetValue) waveform_rsaw_get_float,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_float_value_array,
+ (GstControlSourceGetValue) waveform_rsaw_get_double,
+ (GstControlSourceGetValueArray) waveform_rsaw_get_double_value_array
+};
+
+#define DEFINE_TRIANGLE(type,round) \
+\
+static inline g##type \
+_triangle_get_##type (GstLFOControlSource *self, GstClockTime timestamp) \
+{ \
+ g##type max = g_value_get_##type (&self->priv->maximum_value); \
+ g##type min = g_value_get_##type (&self->priv->minimum_value); \
+ gdouble amp = g_value_get_##type (&self->priv->amplitude); \
+ gdouble off = g_value_get_##type (&self->priv->offset); \
+ GstClockTime period = self->priv->period; \
+ GstClockTime pos = _calculate_pos (timestamp, self->priv->timeshift, period); \
+ gdouble ret; \
+ \
+ if (pos <= period / 4.0) \
+ ret = pos * ((4.0 * amp) / period); \
+ else if (pos <= (3.0 * period) / 4.0) \
+ ret = -(pos - period / 2.0) * ((4.0 * amp) / period); \
+ else \
+ ret = (period - pos) * ((4.0 * amp) / period); \
+ \
+ ret += off; \
+ \
+ if (round) \
+ ret += 0.5; \
+ \
+ return (g##type) CLAMP (ret, min, max); \
+} \
+\
+static gboolean \
+waveform_triangle_get_##type (GstLFOControlSource *self, GstClockTime timestamp, \
+ GValue *value) \
+{ \
+ g##type ret; \
+ g_mutex_lock (self->lock); \
+ ret = _triangle_get_##type (self, timestamp); \
+ g_value_set_##type (value, ret); \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+} \
+\
+static gboolean \
+waveform_triangle_get_##type##_value_array (GstLFOControlSource *self, \
+ GstClockTime timestamp, GstValueArray * value_array) \
+{ \
+ gint i; \
+ GstClockTime ts = timestamp; \
+ g##type *values = (g##type *) value_array->values; \
+ \
+ g_mutex_lock (self->lock); \
+ for(i = 0; i < value_array->nbsamples; i++) { \
+ *values = _triangle_get_##type (self, ts); \
+ ts += value_array->sample_interval; \
+ values++; \
+ } \
+ g_mutex_unlock (self->lock); \
+ return TRUE; \
+}
+
+DEFINE_TRIANGLE (int, TRUE);
+
+DEFINE_TRIANGLE (uint, TRUE);
+DEFINE_TRIANGLE (long, TRUE);
+
+DEFINE_TRIANGLE (ulong, TRUE);
+DEFINE_TRIANGLE (int64, TRUE);
+DEFINE_TRIANGLE (uint64, TRUE);
+DEFINE_TRIANGLE (float, FALSE);
+DEFINE_TRIANGLE (double, FALSE);
+
+static GstWaveformImplementation waveform_triangle = {
+ (GstControlSourceGetValue) waveform_triangle_get_int,
+ (GstControlSourceGetValueArray) waveform_triangle_get_int_value_array,
+ (GstControlSourceGetValue) waveform_triangle_get_uint,
+ (GstControlSourceGetValueArray) waveform_triangle_get_uint_value_array,
+ (GstControlSourceGetValue) waveform_triangle_get_long,
+ (GstControlSourceGetValueArray) waveform_triangle_get_long_value_array,
+ (GstControlSourceGetValue) waveform_triangle_get_ulong,
+ (GstControlSourceGetValueArray) waveform_triangle_get_ulong_value_array,
+ (GstControlSourceGetValue) waveform_triangle_get_int64,
+ (GstControlSourceGetValueArray) waveform_triangle_get_int64_value_array,
+ (GstControlSourceGetValue) waveform_triangle_get_uint64,
+ (GstControlSourceGetValueArray) waveform_triangle_get_uint64_value_array,
+ (GstControlSourceGetValue) waveform_triangle_get_float,
+ (GstControlSourceGetValueArray) waveform_triangle_get_float_value_array,
+ (GstControlSourceGetValue) waveform_triangle_get_double,
+ (GstControlSourceGetValueArray) waveform_triangle_get_double_value_array
+};
+
+static GstWaveformImplementation *waveforms[] = {
+ &waveform_sine,
+ &waveform_square,
+ &waveform_saw,
+ &waveform_rsaw,
+ &waveform_triangle
+};
+
+static guint num_waveforms = G_N_ELEMENTS (waveforms);
+
+enum
+{
+ PROP_WAVEFORM = 1,
+ PROP_FREQUENCY,
+ PROP_TIMESHIFT,
+ PROP_AMPLITUDE,
+ PROP_OFFSET
+};
+
+GType
+gst_lfo_waveform_get_type (void)
+{
+ static GType gtype = 0;
+
+ if (gtype == 0) {
+ static const GEnumValue values[] = {
+ {GST_LFO_WAVEFORM_SINE, "Sine waveform (default)",
+ "sine"},
+ {GST_LFO_WAVEFORM_SQUARE, "Square waveform",
+ "square"},
+ {GST_LFO_WAVEFORM_SAW, "Saw waveform",
+ "saw"},
+ {GST_LFO_WAVEFORM_REVERSE_SAW, "Reverse saw waveform",
+ "reverse-saw"},
+ {GST_LFO_WAVEFORM_TRIANGLE, "Triangle waveform",
+ "triangle"},
+ {0, NULL, NULL}
+ };
+
+ gtype = g_enum_register_static ("GstLFOWaveform", values);
+ }
+ return gtype;
+}
+
+static void gst_lfo_control_source_init (GstLFOControlSource * self);
+static void
+gst_lfo_control_source_class_init (GstLFOControlSourceClass * klass);
+
+G_DEFINE_TYPE (GstLFOControlSource, gst_lfo_control_source,
+ GST_TYPE_CONTROL_SOURCE);
+
+static GObjectClass *parent_class = NULL;
+
+static void
+gst_lfo_control_source_reset (GstLFOControlSource * self)
+{
+ GstControlSource *csource = GST_CONTROL_SOURCE (self);
+
+ csource->get_value = NULL;
+ csource->get_value_array = NULL;
+
+ self->priv->type = self->priv->base = G_TYPE_INVALID;
+
+ if (G_IS_VALUE (&self->priv->minimum_value))
+ g_value_unset (&self->priv->minimum_value);
+ if (G_IS_VALUE (&self->priv->maximum_value))
+ g_value_unset (&self->priv->maximum_value);
+
+ if (G_IS_VALUE (&self->priv->amplitude))
+ g_value_unset (&self->priv->amplitude);
+ if (G_IS_VALUE (&self->priv->offset))
+ g_value_unset (&self->priv->offset);
+}
+
+/**
+ * gst_lfo_control_source_new:
+ *
+ * This returns a new, unbound #GstLFOControlSource.
+ *
+ * Returns: a new, unbound #GstLFOControlSource.
+ */
+GstLFOControlSource *
+gst_lfo_control_source_new ()
+{
+ return g_object_new (GST_TYPE_LFO_CONTROL_SOURCE, NULL);
+}
+
+static gboolean
+gst_lfo_control_source_set_waveform (GstLFOControlSource * self,
+ GstLFOWaveform waveform)
+{
+ GstControlSource *csource = GST_CONTROL_SOURCE (self);
+ gboolean ret = TRUE;
+
+ if (waveform >= num_waveforms || waveform < 0) {
+ GST_WARNING ("waveform %d invalid or not implemented yet", waveform);
+ return FALSE;
+ }
+
+ if (self->priv->base == G_TYPE_INVALID) {
+ GST_WARNING ("not bound to a property yet");
+ return FALSE;
+ }
+
+ switch (self->priv->base) {
+ case G_TYPE_INT:
+ csource->get_value = waveforms[waveform]->get_int;
+ csource->get_value_array = waveforms[waveform]->get_int_value_array;
+ break;
+ case G_TYPE_UINT:{
+ csource->get_value = waveforms[waveform]->get_uint;
+ csource->get_value_array = waveforms[waveform]->get_uint_value_array;
+ break;
+ }
+ case G_TYPE_LONG:{
+ csource->get_value = waveforms[waveform]->get_long;
+ csource->get_value_array = waveforms[waveform]->get_long_value_array;
+ break;
+ }
+ case G_TYPE_ULONG:{
+ csource->get_value = waveforms[waveform]->get_ulong;
+ csource->get_value_array = waveforms[waveform]->get_ulong_value_array;
+ break;
+ }
+ case G_TYPE_INT64:{
+ csource->get_value = waveforms[waveform]->get_int64;
+ csource->get_value_array = waveforms[waveform]->get_int64_value_array;
+ break;
+ }
+ case G_TYPE_UINT64:{
+ csource->get_value = waveforms[waveform]->get_uint64;
+ csource->get_value_array = waveforms[waveform]->get_uint64_value_array;
+ break;
+ }
+ case G_TYPE_FLOAT:{
+ csource->get_value = waveforms[waveform]->get_float;
+ csource->get_value_array = waveforms[waveform]->get_float_value_array;
+ break;
+ }
+ case G_TYPE_DOUBLE:{
+ csource->get_value = waveforms[waveform]->get_double;
+ csource->get_value_array = waveforms[waveform]->get_double_value_array;
+ break;
+ }
+ default:
+ ret = FALSE;
+ break;
+ }
+
+ if (ret)
+ self->priv->waveform = waveform;
+ else
+ GST_WARNING ("incomplete implementation for type '%d'", self->priv->type);
+
+ return ret;
+}
+
+static gboolean
+gst_lfo_control_source_bind (GstControlSource * source, GParamSpec * pspec)
+{
+ GType type, base;
+ GstLFOControlSource *self = GST_LFO_CONTROL_SOURCE (source);
+ gboolean ret = TRUE;
+
+ /* get the fundamental base type */
+ self->priv->type = base = type = G_PARAM_SPEC_VALUE_TYPE (pspec);
+ while ((type = g_type_parent (type)))
+ base = type;
+
+ self->priv->base = base;
+ /* restore type */
+ type = self->priv->type;
+
+ switch (base) {
+ case G_TYPE_INT:{
+ GParamSpecInt *tpspec = G_PARAM_SPEC_INT (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_int (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_int (&self->priv->maximum_value, tpspec->maximum);
+
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_int (&self->priv->amplitude, 0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_int (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ case G_TYPE_UINT:{
+ GParamSpecUInt *tpspec = G_PARAM_SPEC_UINT (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_uint (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_uint (&self->priv->maximum_value, tpspec->maximum);
+
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_uint (&self->priv->amplitude, 0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_uint (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ case G_TYPE_LONG:{
+ GParamSpecLong *tpspec = G_PARAM_SPEC_LONG (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_long (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_long (&self->priv->maximum_value, tpspec->maximum);
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_long (&self->priv->amplitude, 0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_long (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ case G_TYPE_ULONG:{
+ GParamSpecULong *tpspec = G_PARAM_SPEC_ULONG (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_ulong (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_ulong (&self->priv->maximum_value, tpspec->maximum);
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_ulong (&self->priv->amplitude, 0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_ulong (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ case G_TYPE_INT64:{
+ GParamSpecInt64 *tpspec = G_PARAM_SPEC_INT64 (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_int64 (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_int64 (&self->priv->maximum_value, tpspec->maximum);
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_int64 (&self->priv->amplitude, 0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_int64 (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ case G_TYPE_UINT64:{
+ GParamSpecUInt64 *tpspec = G_PARAM_SPEC_UINT64 (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_uint64 (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_uint64 (&self->priv->maximum_value, tpspec->maximum);
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_uint64 (&self->priv->amplitude, 0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_uint64 (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ case G_TYPE_FLOAT:{
+ GParamSpecFloat *tpspec = G_PARAM_SPEC_FLOAT (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_float (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_float (&self->priv->maximum_value, tpspec->maximum);
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_float (&self->priv->amplitude, 0.0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_float (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ case G_TYPE_DOUBLE:{
+ GParamSpecDouble *tpspec = G_PARAM_SPEC_DOUBLE (pspec);
+
+ g_value_init (&self->priv->minimum_value, type);
+ g_value_set_double (&self->priv->minimum_value, tpspec->minimum);
+ g_value_init (&self->priv->maximum_value, type);
+ g_value_set_double (&self->priv->maximum_value, tpspec->maximum);
+ if (!G_IS_VALUE (&self->priv->amplitude)) {
+ g_value_init (&self->priv->amplitude, type);
+ g_value_set_float (&self->priv->amplitude, 0.0);
+ }
+
+ if (!G_IS_VALUE (&self->priv->offset)) {
+ g_value_init (&self->priv->offset, type);
+ g_value_set_float (&self->priv->offset, tpspec->default_value);
+ }
+ break;
+ }
+ default:
+ GST_WARNING ("incomplete implementation for paramspec type '%s'",
+ G_PARAM_SPEC_TYPE_NAME (pspec));
+ ret = FALSE;
+ break;
+ }
+
+ if (ret) {
+ GValue amp = { 0, }
+ , off = {
+ 0,};
+
+ /* This should never fail unless the user already set amplitude or offset
+ * with an incompatible type before _bind () */
+ if (!g_value_type_transformable (G_VALUE_TYPE (&self->priv->amplitude),
+ base)
+ || !g_value_type_transformable (G_VALUE_TYPE (&self->priv->offset),
+ base)) {
+ GST_WARNING ("incompatible types for amplitude or offset");
+ gst_lfo_control_source_reset (self);
+ return FALSE;
+ }
+
+ /* Generate copies and transform to the correct type */
+ g_value_init (&, base);
+ g_value_transform (&self->priv->amplitude, &);
+ g_value_init (&off, base);
+ g_value_transform (&self->priv->offset, &off);
+
+ ret = gst_lfo_control_source_set_waveform (self, self->priv->waveform);
+
+ g_value_unset (&self->priv->amplitude);
+ g_value_init (&self->priv->amplitude, self->priv->base);
+ g_value_transform (&, &self->priv->amplitude);
+
+ g_value_unset (&self->priv->offset);
+ g_value_init (&self->priv->offset, self->priv->base);
+ g_value_transform (&off, &self->priv->offset);
+
+ g_value_unset (&);
+ g_value_unset (&off);
+ }
+
+ if (!ret)
+ gst_lfo_control_source_reset (self);
+
+ return ret;
+}
+
+static void
+gst_lfo_control_source_init (GstLFOControlSource * self)
+{
+ self->priv =
+ G_TYPE_INSTANCE_GET_PRIVATE (self, GST_TYPE_LFO_CONTROL_SOURCE,
+ GstLFOControlSourcePrivate);
+ self->priv->waveform = GST_LFO_WAVEFORM_SINE;
+ self->priv->frequency = 1.0;
+ self->priv->period = GST_SECOND / self->priv->frequency;
+ self->priv->timeshift = 0;
+
+ self->lock = g_mutex_new ();
+}
+
+static void
+gst_lfo_control_source_finalize (GObject * obj)
+{
+ GstLFOControlSource *self = GST_LFO_CONTROL_SOURCE (obj);
+
+ gst_lfo_control_source_reset (self);
+
+ if (self->lock) {
+ g_mutex_free (self->lock);
+ self->lock = NULL;
+ }
+
+ G_OBJECT_CLASS (parent_class)->finalize (obj);
+}
+
+static void
+gst_lfo_control_source_dispose (GObject * obj)
+{
+ G_OBJECT_CLASS (parent_class)->dispose (obj);
+}
+
+static void
+gst_lfo_control_source_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstLFOControlSource *self = GST_LFO_CONTROL_SOURCE (object);
+
+ switch (prop_id) {
+ case PROP_WAVEFORM:
+ g_mutex_lock (self->lock);
+ gst_lfo_control_source_set_waveform (self, g_value_get_enum (value));
+ g_mutex_unlock (self->lock);
+ break;
+ case PROP_FREQUENCY:{
+ gdouble frequency = g_value_get_double (value);
+
+ g_return_if_fail (frequency > 0
+ || ((GstClockTime) (GST_SECOND / frequency)) != 0);
+
+ g_mutex_lock (self->lock);
+ self->priv->frequency = frequency;
+ self->priv->period = GST_SECOND / frequency;
+ g_mutex_unlock (self->lock);
+ break;
+ }
+ case PROP_TIMESHIFT:
+ g_mutex_lock (self->lock);
+ self->priv->timeshift = g_value_get_uint64 (value);
+ g_mutex_unlock (self->lock);
+ break;
+ case PROP_AMPLITUDE:{
+ GValue *val = g_value_get_boxed (value);
+
+ if (self->priv->type != G_TYPE_INVALID) {
+ g_return_if_fail (g_value_type_transformable (self->priv->type,
+ G_VALUE_TYPE (val)));
+
+ g_mutex_lock (self->lock);
+ if (G_IS_VALUE (&self->priv->amplitude))
+ g_value_unset (&self->priv->amplitude);
+
+ g_value_init (&self->priv->amplitude, self->priv->type);
+ g_value_transform (val, &self->priv->amplitude);
+ g_mutex_unlock (self->lock);
+ } else {
+ g_mutex_lock (self->lock);
+ if (G_IS_VALUE (&self->priv->amplitude))
+ g_value_unset (&self->priv->amplitude);
+
+ g_value_init (&self->priv->amplitude, G_VALUE_TYPE (val));
+ g_value_copy (val, &self->priv->amplitude);
+ g_mutex_unlock (self->lock);
+ }
+
+ break;
+ }
+ case PROP_OFFSET:{
+ GValue *val = g_value_get_boxed (value);
+
+ if (self->priv->type != G_TYPE_INVALID) {
+ g_return_if_fail (g_value_type_transformable (self->priv->type,
+ G_VALUE_TYPE (val)));
+
+ g_mutex_lock (self->lock);
+ if (G_IS_VALUE (&self->priv->offset))
+ g_value_unset (&self->priv->offset);
+
+ g_value_init (&self->priv->offset, self->priv->type);
+ g_value_transform (val, &self->priv->offset);
+ g_mutex_unlock (self->lock);
+ } else {
+ g_mutex_lock (self->lock);
+ if (G_IS_VALUE (&self->priv->offset))
+ g_value_unset (&self->priv->offset);
+
+ g_value_init (&self->priv->offset, G_VALUE_TYPE (val));
+ g_value_copy (val, &self->priv->offset);
+ g_mutex_unlock (self->lock);
+ }
+
+ break;
+ }
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_lfo_control_source_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GstLFOControlSource *self = GST_LFO_CONTROL_SOURCE (object);
+
+ switch (prop_id) {
+ case PROP_WAVEFORM:
+ g_value_set_enum (value, self->priv->waveform);
+ break;
+ case PROP_FREQUENCY:
+ g_value_set_double (value, self->priv->frequency);
+ break;
+ case PROP_TIMESHIFT:
+ g_value_set_uint64 (value, self->priv->timeshift);
+ break;
+ case PROP_AMPLITUDE:
+ g_value_set_boxed (value, &self->priv->amplitude);
+ break;
+ case PROP_OFFSET:
+ g_value_set_boxed (value, &self->priv->offset);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_lfo_control_source_class_init (GstLFOControlSourceClass * klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GstControlSourceClass *csource_class = GST_CONTROL_SOURCE_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
+ g_type_class_add_private (klass, sizeof (GstLFOControlSourcePrivate));
+
+ gobject_class->finalize = gst_lfo_control_source_finalize;
+ gobject_class->dispose = gst_lfo_control_source_dispose;
+ gobject_class->set_property = gst_lfo_control_source_set_property;
+ gobject_class->get_property = gst_lfo_control_source_get_property;
+
+ csource_class->bind = gst_lfo_control_source_bind;
+
+ /**
+ * GstLFOControlSource:waveform
+ *
+ * Specifies the waveform that should be used for this #GstLFOControlSource.
+ *
+ **/
+ g_object_class_install_property (gobject_class, PROP_WAVEFORM,
+ g_param_spec_enum ("waveform", "Waveform", "Waveform",
+ GST_TYPE_LFO_WAVEFORM, GST_LFO_WAVEFORM_SINE, G_PARAM_READWRITE));
+
+ /**
+ * GstLFOControlSource:frequency
+ *
+ * Specifies the frequency that should be used for the waveform
+ * of this #GstLFOControlSource. It should be large enough
+ * so that the period is longer than one nanosecond.
+ *
+ **/
+ g_object_class_install_property (gobject_class, PROP_FREQUENCY,
+ g_param_spec_double ("frequency", "Frequency",
+ "Frequency of the waveform", 0.0, G_MAXDOUBLE, 1.0,
+ G_PARAM_READWRITE));
+
+ /**
+ * GstLFOControlSource:timeshift
+ *
+ * Specifies the timeshift to the right that should be used for the waveform
+ * of this #GstLFOControlSource in nanoseconds.
+ *
+ * To get a n nanosecond shift to the left use
+ * "(GST_SECOND / frequency) - n".
+ *
+ **/
+ g_object_class_install_property (gobject_class, PROP_TIMESHIFT,
+ g_param_spec_uint64 ("timeshift", "Timeshift",
+ "Timeshift of the waveform to the right", 0, G_MAXUINT64, 0,
+ G_PARAM_READWRITE));
+
+ /**
+ * GstLFOControlSource:amplitude
+ *
+ * Specifies the amplitude for the waveform of this #GstLFOControlSource.
+ *
+ * It should be given as a #GValue with a type that can be transformed
+ * to the type of the bound property.
+ **/
+ g_object_class_install_property (gobject_class, PROP_AMPLITUDE,
+ g_param_spec_boxed ("amplitude", "Amplitude", "Amplitude of the waveform",
+ G_TYPE_VALUE, G_PARAM_READWRITE));
+
+ /**
+ * GstLFOControlSource:offset
+ *
+ * Specifies the offset for the waveform of this #GstLFOControlSource.
+ *
+ * It should be given as a #GValue with a type that can be transformed
+ * to the type of the bound property.
+ **/
+ g_object_class_install_property (gobject_class, PROP_OFFSET,
+ g_param_spec_boxed ("offset", "Offset", "Offset of the waveform",
+ G_TYPE_VALUE, G_PARAM_READWRITE));
+}
* unit test for the controller library
*
* Copyright (C) <2005> Stefan Kost <ensonic at users dot sf dot net>
- * Copyright (C) <2006> Sebastian Dröge <slomo@circular-chaos.org>
+ * Copyright (C) <2006-2007> Sebastian Dröge <slomo@circular-chaos.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
#include <gst/controller/gstcontroller.h>
#include <gst/controller/gstcontrolsource.h>
#include <gst/controller/gstinterpolationcontrolsource.h>
+#include <gst/controller/gstlfocontrolsource.h>
/* LOCAL TEST ELEMENT */
GST_END_TEST;
+/* test lfo control source with sine waveform */
+GST_START_TEST (controller_lfo_sine)
+{
+ GstController *ctrl;
+ GstLFOControlSource *csource;
+ GstElement *elem;
+ GValue amp = { 0, }
+ , off = {
+ 0,};
+
+ gst_controller_init (NULL, NULL);
+
+ elem = gst_element_factory_make ("testmonosource", "test_source");
+
+ /* that property should exist and should be controllable */
+ ctrl = gst_controller_new (G_OBJECT (elem), "ulong", NULL);
+ fail_unless (ctrl != NULL, NULL);
+
+ /* Get interpolation control source */
+ csource = gst_lfo_control_source_new ();
+
+ fail_unless (csource != NULL);
+ fail_unless (gst_controller_set_control_source (ctrl, "ulong",
+ GST_CONTROL_SOURCE (csource)));
+
+ /* set amplitude and offset values */
+ g_value_init (&, G_TYPE_ULONG);
+ g_value_init (&off, G_TYPE_ULONG);
+ g_value_set_ulong (&, 100);
+ g_value_set_ulong (&off, 100);
+
+ /* set waveform mode */
+ g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SINE,
+ "frequency", 1.0, "timeshift", (GstClockTime) 0,
+ "amplitude", &, "offset", &off, NULL);
+
+ g_object_unref (G_OBJECT (csource));
+
+ /* now pull in values for some timestamps */
+ gst_controller_sync_values (ctrl, 0 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 2000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+
+ GST_INFO ("controller->ref_count=%d", G_OBJECT (ctrl)->ref_count);
+ g_object_unref (ctrl);
+ gst_object_unref (elem);
+}
+
+GST_END_TEST;
+
+/* test lfo control source with sine waveform and timeshift */
+GST_START_TEST (controller_lfo_sine_timeshift)
+{
+ GstController *ctrl;
+ GstLFOControlSource *csource;
+ GstElement *elem;
+ GValue amp = { 0, }
+ , off = {
+ 0,};
+
+ gst_controller_init (NULL, NULL);
+
+ elem = gst_element_factory_make ("testmonosource", "test_source");
+
+ /* that property should exist and should be controllable */
+ ctrl = gst_controller_new (G_OBJECT (elem), "ulong", NULL);
+ fail_unless (ctrl != NULL, NULL);
+
+ /* Get interpolation control source */
+ csource = gst_lfo_control_source_new ();
+
+ fail_unless (csource != NULL);
+ fail_unless (gst_controller_set_control_source (ctrl, "ulong",
+ GST_CONTROL_SOURCE (csource)));
+
+ /* set amplitude and offset values */
+ g_value_init (&, G_TYPE_ULONG);
+ g_value_init (&off, G_TYPE_ULONG);
+ g_value_set_ulong (&, 100);
+ g_value_set_ulong (&off, 100);
+
+ /* set waveform mode */
+ g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SINE,
+ "frequency", 1.0, "timeshift", 250 * GST_MSECOND,
+ "amplitude", &, "offset", &off, NULL);
+
+ g_object_unref (G_OBJECT (csource));
+
+/* now pull in values for some timestamps */
+ gst_controller_sync_values (ctrl, 0 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 2000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+
+ GST_INFO ("controller->ref_count=%d", G_OBJECT (ctrl)->ref_count);
+ g_object_unref (ctrl);
+ gst_object_unref (elem);
+}
+
+GST_END_TEST;
+
+
+/* test lfo control source with square waveform */
+GST_START_TEST (controller_lfo_square)
+{
+ GstController *ctrl;
+ GstLFOControlSource *csource;
+ GstElement *elem;
+ GValue amp = { 0, }
+ , off = {
+ 0,};
+
+ gst_controller_init (NULL, NULL);
+
+ elem = gst_element_factory_make ("testmonosource", "test_source");
+
+ /* that property should exist and should be controllable */
+ ctrl = gst_controller_new (G_OBJECT (elem), "ulong", NULL);
+ fail_unless (ctrl != NULL, NULL);
+
+ /* Get interpolation control source */
+ csource = gst_lfo_control_source_new ();
+
+ fail_unless (csource != NULL);
+ fail_unless (gst_controller_set_control_source (ctrl, "ulong",
+ GST_CONTROL_SOURCE (csource)));
+
+ /* set amplitude and offset values */
+ g_value_init (&, G_TYPE_ULONG);
+ g_value_init (&off, G_TYPE_ULONG);
+ g_value_set_ulong (&, 100);
+ g_value_set_ulong (&off, 100);
+
+ /* set waveform mode */
+ g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SQUARE,
+ "frequency", 1.0, "timeshift", (GstClockTime) 0,
+ "amplitude", &, "offset", &off, NULL);
+
+ g_object_unref (G_OBJECT (csource));
+
+ /* now pull in values for some timestamps */
+ gst_controller_sync_values (ctrl, 0 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 2000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+
+ GST_INFO ("controller->ref_count=%d", G_OBJECT (ctrl)->ref_count);
+ g_object_unref (ctrl);
+ gst_object_unref (elem);
+}
+
+GST_END_TEST;
+
+/* test lfo control source with saw waveform */
+GST_START_TEST (controller_lfo_saw)
+{
+ GstController *ctrl;
+ GstLFOControlSource *csource;
+ GstElement *elem;
+ GValue amp = { 0, }
+ , off = {
+ 0,};
+
+ gst_controller_init (NULL, NULL);
+
+ elem = gst_element_factory_make ("testmonosource", "test_source");
+
+ /* that property should exist and should be controllable */
+ ctrl = gst_controller_new (G_OBJECT (elem), "ulong", NULL);
+ fail_unless (ctrl != NULL, NULL);
+
+ /* Get interpolation control source */
+ csource = gst_lfo_control_source_new ();
+
+ fail_unless (csource != NULL);
+ fail_unless (gst_controller_set_control_source (ctrl, "ulong",
+ GST_CONTROL_SOURCE (csource)));
+
+ /* set amplitude and offset values */
+ g_value_init (&, G_TYPE_ULONG);
+ g_value_init (&off, G_TYPE_ULONG);
+ g_value_set_ulong (&, 100);
+ g_value_set_ulong (&off, 100);
+
+ /* set waveform mode */
+ g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SAW,
+ "frequency", 1.0, "timeshift", (GstClockTime) 0,
+ "amplitude", &, "offset", &off, NULL);
+
+ g_object_unref (G_OBJECT (csource));
+
+ /* now pull in values for some timestamps */
+ gst_controller_sync_values (ctrl, 0 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 150, NULL);
+ gst_controller_sync_values (ctrl, 500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 50, NULL);
+ gst_controller_sync_values (ctrl, 1000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 150, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 50, NULL);
+ gst_controller_sync_values (ctrl, 2000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 150, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 50, NULL);
+
+ GST_INFO ("controller->ref_count=%d", G_OBJECT (ctrl)->ref_count);
+ g_object_unref (ctrl);
+ gst_object_unref (elem);
+}
+
+GST_END_TEST;
+
+/* test lfo control source with reverse saw waveform */
+GST_START_TEST (controller_lfo_rsaw)
+{
+ GstController *ctrl;
+ GstLFOControlSource *csource;
+ GstElement *elem;
+ GValue amp = { 0, }
+ , off = {
+ 0,};
+
+ gst_controller_init (NULL, NULL);
+
+ elem = gst_element_factory_make ("testmonosource", "test_source");
+
+ /* that property should exist and should be controllable */
+ ctrl = gst_controller_new (G_OBJECT (elem), "ulong", NULL);
+ fail_unless (ctrl != NULL, NULL);
+
+ /* Get interpolation control source */
+ csource = gst_lfo_control_source_new ();
+
+ fail_unless (csource != NULL);
+ fail_unless (gst_controller_set_control_source (ctrl, "ulong",
+ GST_CONTROL_SOURCE (csource)));
+
+ /* set amplitude and offset values */
+ g_value_init (&, G_TYPE_ULONG);
+ g_value_init (&off, G_TYPE_ULONG);
+ g_value_set_ulong (&, 100);
+ g_value_set_ulong (&off, 100);
+
+ /* set waveform mode */
+ g_object_set (csource, "waveform", GST_LFO_WAVEFORM_REVERSE_SAW,
+ "frequency", 1.0, "timeshift", (GstClockTime) 0,
+ "amplitude", &, "offset", &off, NULL);
+
+ g_object_unref (G_OBJECT (csource));
+
+ /* now pull in values for some timestamps */
+ gst_controller_sync_values (ctrl, 0 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 50, NULL);
+ gst_controller_sync_values (ctrl, 500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 150, NULL);
+ gst_controller_sync_values (ctrl, 1000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 50, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 150, NULL);
+ gst_controller_sync_values (ctrl, 2000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 50, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 150, NULL);
+
+ GST_INFO ("controller->ref_count=%d", G_OBJECT (ctrl)->ref_count);
+ g_object_unref (ctrl);
+ gst_object_unref (elem);
+}
+
+GST_END_TEST;
+
+/* test lfo control source with saw waveform */
+GST_START_TEST (controller_lfo_triangle)
+{
+ GstController *ctrl;
+ GstLFOControlSource *csource;
+ GstElement *elem;
+ GValue amp = { 0, }
+ , off = {
+ 0,};
+
+ gst_controller_init (NULL, NULL);
+
+ elem = gst_element_factory_make ("testmonosource", "test_source");
+
+ /* that property should exist and should be controllable */
+ ctrl = gst_controller_new (G_OBJECT (elem), "ulong", NULL);
+ fail_unless (ctrl != NULL, NULL);
+
+ /* Get interpolation control source */
+ csource = gst_lfo_control_source_new ();
+
+ fail_unless (csource != NULL);
+ fail_unless (gst_controller_set_control_source (ctrl, "ulong",
+ GST_CONTROL_SOURCE (csource)));
+
+ /* set amplitude and offset values */
+ g_value_init (&, G_TYPE_ULONG);
+ g_value_init (&off, G_TYPE_ULONG);
+ g_value_set_ulong (&, 100);
+ g_value_set_ulong (&off, 100);
+
+ /* set waveform mode */
+ g_object_set (csource, "waveform", GST_LFO_WAVEFORM_TRIANGLE,
+ "frequency", 1.0, "timeshift", (GstClockTime) 0,
+ "amplitude", &, "offset", &off, NULL);
+
+ g_object_unref (G_OBJECT (csource));
+
+ /* now pull in values for some timestamps */
+ gst_controller_sync_values (ctrl, 0 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 2000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 200, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 100, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+
+ GST_INFO ("controller->ref_count=%d", G_OBJECT (ctrl)->ref_count);
+ g_object_unref (ctrl);
+ gst_object_unref (elem);
+}
+
+GST_END_TEST;
+
+/* test lfo control source with nothing set */
+GST_START_TEST (controller_lfo_none)
+{
+ GstController *ctrl;
+ GstLFOControlSource *csource;
+ GstElement *elem;
+
+ gst_controller_init (NULL, NULL);
+
+ elem = gst_element_factory_make ("testmonosource", "test_source");
+
+ /* that property should exist and should be controllable */
+ ctrl = gst_controller_new (G_OBJECT (elem), "ulong", NULL);
+ fail_unless (ctrl != NULL, NULL);
+
+ /* Get interpolation control source */
+ csource = gst_lfo_control_source_new ();
+
+ fail_unless (csource != NULL);
+ fail_unless (gst_controller_set_control_source (ctrl, "ulong",
+ GST_CONTROL_SOURCE (csource)));
+
+ g_object_unref (G_OBJECT (csource));
+
+ /* now pull in values for some timestamps */
+ gst_controller_sync_values (ctrl, 0 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 2000 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1250 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1500 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+ gst_controller_sync_values (ctrl, 1750 * GST_MSECOND);
+ fail_unless (GST_TEST_MONO_SOURCE (elem)->val_ulong == 0, NULL);
+
+ GST_INFO ("controller->ref_count=%d", G_OBJECT (ctrl)->ref_count);
+ g_object_unref (ctrl);
+ gst_object_unref (elem);
+}
+
+GST_END_TEST;
+
/* tests if we can run helper methods against any GObject */
GST_START_TEST (controller_helper_any_gobject)
{
tcase_add_test (tc, controller_interpolation_linear_default_values);
tcase_add_test (tc, controller_interpolate_linear_disabled);
tcase_add_test (tc, controller_interpolation_set_from_list);
+ tcase_add_test (tc, controller_lfo_sine);
+ tcase_add_test (tc, controller_lfo_sine_timeshift);
+ tcase_add_test (tc, controller_lfo_square);
+ tcase_add_test (tc, controller_lfo_saw);
+ tcase_add_test (tc, controller_lfo_rsaw);
+ tcase_add_test (tc, controller_lfo_triangle);
+ tcase_add_test (tc, controller_lfo_none);
tcase_add_test (tc, controller_helper_any_gobject);
return s;
projects / platform / upstream / gstreamer.git / commitdiff