tests/check/libs/controller.c

   1 /* GStreamer
   2  *
   3  * unit test for the controller library
   4  *
   5  * Copyright (C) <2005> Stefan Kost <ensonic at users dot sf dot net>
   6  * Copyright (C) <2006-2007> Sebastian Dröge <slomo@circular-chaos.org>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27 #include <gst/gst.h>
  28 #include <gst/check/gstcheck.h>
  29 #include <gst/controller/gstinterpolationcontrolsource.h>
  30 #include <gst/controller/gstlfocontrolsource.h>
  31 #include <gst/controller/gsttriggercontrolsource.h>
  32 #include <gst/controller/gstcontrolbindingdirect.h>
  33
  34 /* enum for text element */
  35
  36 #define GST_TYPE_TEST_ENUM (gst_test_enum_get_type ())
  37
  38 typedef enum
  39 {
  40   ENUM_V0 = 0,
  41   ENUM_V10 = 10,
  42   ENUM_V11,
  43   ENUM_V12,
  44   ENUM_V255 = 255
  45 } GstTestEnum;
  46
  47 static GType
  48 gst_test_enum_get_type (void)
  49 {
  50   static gsize gtype = 0;
  51   static const GEnumValue values[] = {
  52     {ENUM_V0, "ENUM_V0", "0"},
  53     {ENUM_V10, "ENUM_V10", "10"},
  54     {ENUM_V11, "ENUM_V11", "11"},
  55     {ENUM_V12, "ENUM_V12", "12"},
  56     {ENUM_V255, "ENUM_V255", "255"},
  57     {0, NULL, NULL}
  58   };
  59
  60   if (g_once_init_enter (&gtype)) {
  61     GType tmp = g_enum_register_static ("GstTestEnum", values);
  62     g_once_init_leave (&gtype, tmp);
  63   }
  64
  65   return (GType) gtype;
  66 }
  67
  68 /* local test element */
  69
  70 enum
  71 {
  72   PROP_INT = 1,
  73   PROP_FLOAT,
  74   PROP_DOUBLE,
  75   PROP_BOOLEAN,
  76   PROP_ENUM,
  77   PROP_READONLY,
  78   PROP_STATIC,
  79   PROP_CONSTRUCTONLY,
  80   PROP_COUNT
  81 };
  82
  83 #define GST_TYPE_TEST_OBJ            (gst_test_obj_get_type ())
  84 #define GST_TEST_OBJ(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_TEST_OBJ, GstTestObj))
  85 #define GST_TEST_OBJ_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_TEST_OBJ, GstTestObjClass))
  86 #define GST_IS_TEST_OBJ(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_TEST_OBJ))
  87 #define GST_IS_TEST_OBJ_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_TEST_OBJ))
  88 #define GST_TEST_OBJ_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_TEST_OBJ, GstTestObjClass))
  89
  90 typedef struct _GstTestObj GstTestObj;
  91 typedef struct _GstTestObjClass GstTestObjClass;
  92
  93 struct _GstTestObj
  94 {
  95   GstElement parent;
  96   gint val_int;
  97   gfloat val_float;
  98   gdouble val_double;
  99   gboolean val_boolean;
 100   GstTestEnum val_enum;
 101 };
 102 struct _GstTestObjClass
 103 {
 104   GstElementClass parent_class;
 105 };
 106
 107 static GType gst_test_obj_get_type (void);
 108
 109 static void
 110 gst_test_obj_get_property (GObject * object,
 111     guint property_id, GValue * value, GParamSpec * pspec)
 112 {
 113   GstTestObj *self = GST_TEST_OBJ (object);
 114
 115   switch (property_id) {
 116     case PROP_INT:
 117       g_value_set_int (value, self->val_int);
 118       break;
 119     case PROP_FLOAT:
 120       g_value_set_float (value, self->val_float);
 121       break;
 122     case PROP_DOUBLE:
 123       g_value_set_double (value, self->val_double);
 124       break;
 125     case PROP_BOOLEAN:
 126       g_value_set_boolean (value, self->val_boolean);
 127       break;
 128     case PROP_ENUM:
 129       g_value_set_enum (value, self->val_enum);
 130       break;
 131     default:
 132       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 133       break;
 134   }
 135 }
 136
 137 static void
 138 gst_test_obj_set_property (GObject * object,
 139     guint property_id, const GValue * value, GParamSpec * pspec)
 140 {
 141   GstTestObj *self = GST_TEST_OBJ (object);
 142
 143   switch (property_id) {
 144     case PROP_INT:
 145       self->val_int = g_value_get_int (value);
 146       GST_DEBUG ("test value int=%d", self->val_int);
 147       break;
 148     case PROP_FLOAT:
 149       self->val_float = g_value_get_float (value);
 150       GST_DEBUG ("test value float=%f", self->val_float);
 151       break;
 152     case PROP_DOUBLE:
 153       self->val_double = g_value_get_double (value);
 154       GST_DEBUG ("test value double=%lf", self->val_double);
 155       break;
 156     case PROP_BOOLEAN:
 157       self->val_boolean = g_value_get_boolean (value);
 158       GST_DEBUG ("test value boolean=%d", self->val_boolean);
 159       break;
 160     case PROP_ENUM:
 161       self->val_enum = g_value_get_enum (value);
 162       GST_DEBUG ("test value enum=%d", self->val_enum);
 163       break;
 164     case PROP_CONSTRUCTONLY:
 165       break;
 166     default:
 167       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 168       break;
 169   }
 170 }
 171
 172 static void
 173 gst_test_obj_class_init (GstTestObjClass * klass)
 174 {
 175   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 176
 177   gobject_class->set_property = gst_test_obj_set_property;
 178   gobject_class->get_property = gst_test_obj_get_property;
 179
 180   g_object_class_install_property (gobject_class, PROP_INT,
 181       g_param_spec_int ("int",
 182           "int prop",
 183           "int number parameter",
 184           0, 100, 0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 185
 186   g_object_class_install_property (gobject_class, PROP_FLOAT,
 187       g_param_spec_float ("float",
 188           "float prop",
 189           "float number parameter",
 190           0.0, 100.0, 0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 191
 192   g_object_class_install_property (gobject_class, PROP_DOUBLE,
 193       g_param_spec_double ("double",
 194           "double prop",
 195           "double number parameter",
 196           0.0, 100.0, 0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 197
 198   g_object_class_install_property (gobject_class, PROP_BOOLEAN,
 199       g_param_spec_boolean ("boolean",
 200           "boolean prop",
 201           "boolean parameter",
 202           FALSE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 203
 204   g_object_class_install_property (gobject_class, PROP_ENUM,
 205       g_param_spec_enum ("enum",
 206           "enum prop",
 207           "enum parameter",
 208           GST_TYPE_TEST_ENUM, ENUM_V0,
 209           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 210
 211   g_object_class_install_property (gobject_class, PROP_READONLY,
 212       g_param_spec_int ("readonly",
 213           "readonly prop",
 214           "readonly parameter",
 215           0, G_MAXINT, 0, G_PARAM_READABLE | GST_PARAM_CONTROLLABLE));
 216
 217   g_object_class_install_property (gobject_class, PROP_STATIC,
 218       g_param_spec_int ("static",
 219           "static prop",
 220           "static parameter", 0, G_MAXINT, 0, G_PARAM_READWRITE));
 221
 222   g_object_class_install_property (gobject_class, PROP_CONSTRUCTONLY,
 223       g_param_spec_int ("construct-only",
 224           "construct-only prop",
 225           "construct-only parameter",
 226           0, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 227 }
 228
 229 static void
 230 gst_test_obj_base_init (GstTestObjClass * klass)
 231 {
 232   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 233
 234   gst_element_class_set_details_simple (element_class,
 235       "test object for unit tests",
 236       "Test", "Use in unit tests", "Stefan Sauer <ensonic@users.sf.net>");
 237 }
 238
 239 static GType
 240 gst_test_obj_get_type (void)
 241 {
 242   static volatile gsize test_obj_type = 0;
 243
 244   if (g_once_init_enter (&test_obj_type)) {
 245     GType type;
 246     static const GTypeInfo info = {
 247       (guint16) sizeof (GstTestObjClass),
 248       (GBaseInitFunc) gst_test_obj_base_init,   // base_init
 249       NULL,                     // base_finalize
 250       (GClassInitFunc) gst_test_obj_class_init, // class_init
 251       NULL,                     // class_finalize
 252       NULL,                     // class_data
 253       (guint16) sizeof (GstTestObj),
 254       0,                        // n_preallocs
 255       NULL,                     // instance_init
 256       NULL                      // value_table
 257     };
 258     type = g_type_register_static (GST_TYPE_ELEMENT, "GstTestObj", &info, 0);
 259     g_once_init_leave (&test_obj_type, type);
 260   }
 261   return test_obj_type;
 262 }
 263
 264 static void
 265 setup (void)
 266 {
 267   gst_element_register (NULL, "testobj", GST_RANK_NONE, GST_TYPE_TEST_OBJ);
 268 }
 269
 270 static void
 271 teardown (void)
 272 {
 273 }
 274
 275
 276 /* TESTS */
 277
 278 /* tests if we don't fail on empty interpolation controlsources */
 279 GST_START_TEST (controller_controlsource_empty1)
 280 {
 281   GstElement *elem;
 282   GstControlSource *csource;
 283
 284   elem = gst_element_factory_make ("testobj", NULL);
 285
 286   csource = (GstControlSource *) gst_interpolation_control_source_new ();
 287   fail_unless (csource != NULL, NULL);
 288
 289   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 290           gst_control_binding_direct_new (GST_OBJECT (elem), "int",
 291               (GstControlSource *) csource)));
 292
 293   /* don't fail on empty control point lists */
 294   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 295
 296   /* unref objects */
 297   gst_object_unref (csource);
 298   gst_object_unref (elem);
 299 }
 300
 301 GST_END_TEST;
 302
 303 /* tests if we don't fail on interpolation controlsources that are empty again */
 304 GST_START_TEST (controller_controlsource_empty2)
 305 {
 306   GstElement *elem;
 307   GstInterpolationControlSource *csource;
 308   GstTimedValueControlSource *cs;
 309
 310   elem = gst_element_factory_make ("testobj", NULL);
 311
 312   csource = gst_interpolation_control_source_new ();
 313   fail_unless (csource != NULL, NULL);
 314
 315   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 316           gst_control_binding_direct_new (GST_OBJECT (elem), "int",
 317               (GstControlSource *) csource)));
 318
 319   /* set control values */
 320   cs = (GstTimedValueControlSource *) csource;
 321   gst_timed_value_control_source_set (cs, 0 * GST_SECOND, 0);
 322
 323   /* ... and unset the value */
 324   gst_timed_value_control_source_unset (cs, 0 * GST_SECOND);
 325
 326   /* don't fail on empty control point lists */
 327   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 328
 329   /* unref objects */
 330   gst_object_unref (csource);
 331   gst_object_unref (elem);
 332 }
 333
 334 GST_END_TEST;
 335
 336 /* test timed value handling without interpolation */
 337 GST_START_TEST (controller_interpolation_none)
 338 {
 339   GstInterpolationControlSource *csource;
 340   GstTimedValueControlSource *tvcs;
 341   GstControlSource *cs;
 342   GstElement *elem;
 343   gdouble v;
 344
 345   elem = gst_element_factory_make ("testobj", NULL);
 346
 347   /* new interpolation control source */
 348   csource = gst_interpolation_control_source_new ();
 349   tvcs = (GstTimedValueControlSource *) csource;
 350   cs = (GstControlSource *) csource;
 351
 352   fail_unless (csource != NULL);
 353   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 354           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 355
 356   /* set interpolation mode */
 357   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_NONE, NULL);
 358
 359   /* set control values */
 360   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 361   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 1.0));
 362
 363   /* check values on control source directly */
 364   fail_unless (gst_control_source_get_value (cs, 0 * GST_SECOND, &v));
 365   fail_unless_equals_float (v, 0.0);
 366   fail_unless (gst_control_source_get_value (cs, 1 * GST_SECOND, &v));
 367   fail_unless_equals_float (v, 0.0);
 368   fail_unless (gst_control_source_get_value (cs, 2 * GST_SECOND, &v));
 369   fail_unless_equals_float (v, 1.0);
 370   fail_unless (gst_control_source_get_value (cs, 3 * GST_SECOND, &v));
 371   fail_unless_equals_float (v, 1.0);
 372
 373   /* now pull in values for some timestamps */
 374   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 375   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 376   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 377   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 378   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 379   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 380   gst_object_sync_values (GST_OBJECT (elem), 3 * GST_SECOND);
 381   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 382
 383   gst_object_unref (csource);
 384   gst_object_unref (elem);
 385 }
 386
 387 GST_END_TEST;
 388
 389 /* test timed value handling with linear interpolation */
 390 GST_START_TEST (controller_interpolation_linear)
 391 {
 392   GstInterpolationControlSource *csource;
 393   GstTimedValueControlSource *tvcs;
 394   GstControlSource *cs;
 395   GstElement *elem;
 396
 397   elem = gst_element_factory_make ("testobj", NULL);
 398
 399   /* new interpolation control source */
 400   csource = gst_interpolation_control_source_new ();
 401   tvcs = (GstTimedValueControlSource *) csource;
 402   cs = (GstControlSource *) csource;
 403
 404   fail_unless (csource != NULL);
 405   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 406           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 407
 408   /* set interpolation mode */
 409   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 410
 411   /* set control values */
 412   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 413   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 1.0));
 414
 415   /* now pull in values for some timestamps */
 416   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 417   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 418   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 419   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 420   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 421   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 422
 423   gst_object_unref (csource);
 424   gst_object_unref (elem);
 425 }
 426
 427 GST_END_TEST;
 428
 429 /* test timed value handling with cubic interpolation */
 430 GST_START_TEST (controller_interpolation_cubic)
 431 {
 432   GstInterpolationControlSource *csource;
 433   GstTimedValueControlSource *tvcs;
 434   GstControlSource *cs;
 435   GstElement *elem;
 436
 437   elem = gst_element_factory_make ("testobj", NULL);
 438
 439   /* new interpolation control source */
 440   csource = gst_interpolation_control_source_new ();
 441   tvcs = (GstTimedValueControlSource *) csource;
 442   cs = (GstControlSource *) csource;
 443
 444   fail_unless (csource != NULL);
 445   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 446           gst_control_binding_direct_new (GST_OBJECT (elem), "double", cs)));
 447
 448   /* set interpolation mode */
 449   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_CUBIC, NULL);
 450
 451   /* set control values */
 452   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 453   fail_unless (gst_timed_value_control_source_set (tvcs, 1 * GST_SECOND, 0.5));
 454   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 0.2));
 455   fail_unless (gst_timed_value_control_source_set (tvcs, 4 * GST_SECOND, 0.8));
 456
 457   /* now pull in values for some timestamps */
 458   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 459   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 460   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 461   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 50.0);
 462   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 463   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 20.0);
 464   gst_object_sync_values (GST_OBJECT (elem), 3 * GST_SECOND);
 465   fail_unless (GST_TEST_OBJ (elem)->val_double > 20.0 &&
 466       GST_TEST_OBJ (elem)->val_double < 80.0, NULL);
 467   gst_object_sync_values (GST_OBJECT (elem), 4 * GST_SECOND);
 468   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 80.0);
 469   gst_object_sync_values (GST_OBJECT (elem), 5 * GST_SECOND);
 470   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 80.0);
 471
 472   gst_object_unref (csource);
 473   gst_object_unref (elem);
 474 }
 475
 476 GST_END_TEST;
 477
 478 /* test timed value handling with cubic interpolation */
 479 GST_START_TEST (controller_interpolation_cubic_too_few_cp)
 480 {
 481   GstInterpolationControlSource *csource;
 482   GstTimedValueControlSource *tvcs;
 483   GstControlSource *cs;
 484   GstElement *elem;
 485
 486   elem = gst_element_factory_make ("testobj", NULL);
 487
 488   /* new interpolation control source */
 489   csource = gst_interpolation_control_source_new ();
 490   tvcs = (GstTimedValueControlSource *) csource;
 491   cs = (GstControlSource *) csource;
 492
 493   fail_unless (csource != NULL);
 494   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 495           gst_control_binding_direct_new (GST_OBJECT (elem), "double", cs)));
 496
 497   /* set interpolation mode */
 498   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_CUBIC, NULL);
 499
 500   /* set 2 control values */
 501   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 502   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 0.4));
 503
 504   /* now pull in values for some timestamps and verify that it used linear
 505    * interpolation as we don't gave enough control points
 506    */
 507   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 508   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 509   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 510   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 20.0);
 511   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 512   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 40.0);
 513
 514   gst_object_unref (csource);
 515   gst_object_unref (elem);
 516 }
 517
 518 GST_END_TEST;
 519
 520 /* test _unset() */
 521 GST_START_TEST (controller_interpolation_unset)
 522 {
 523   GstInterpolationControlSource *csource;
 524   GstTimedValueControlSource *tvcs;
 525   GstControlSource *cs;
 526   GstElement *elem;
 527
 528   elem = gst_element_factory_make ("testobj", NULL);
 529
 530   /* new interpolation control source */
 531   csource = gst_interpolation_control_source_new ();
 532   tvcs = (GstTimedValueControlSource *) csource;
 533   cs = (GstControlSource *) csource;
 534
 535   fail_unless (csource != NULL);
 536   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 537           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 538
 539   /* set interpolation mode */
 540   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_NONE, NULL);
 541
 542   /* set control values */
 543   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 544   fail_unless (gst_timed_value_control_source_set (tvcs, 1 * GST_SECOND, 1.0));
 545   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 0.5));
 546
 547   /* verify values */
 548   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 549   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 550   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 551   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 552   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 553   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 554
 555   /* unset second */
 556   fail_unless (gst_timed_value_control_source_unset (tvcs, 1 * GST_SECOND));
 557
 558   /* verify value again */
 559   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 560   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 561   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 562   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 563
 564   /* unset all values, reset and try to unset again */
 565   fail_unless (gst_timed_value_control_source_unset (tvcs, 0 * GST_SECOND));
 566   fail_unless (gst_timed_value_control_source_unset (tvcs, 2 * GST_SECOND));
 567   gst_timed_value_control_source_unset_all (tvcs);
 568   fail_if (gst_timed_value_control_source_unset (tvcs, 2 * GST_SECOND));
 569
 570   gst_object_unref (csource);
 571   gst_object_unref (elem);
 572 }
 573
 574 GST_END_TEST;
 575
 576 /* test _unset_all() */
 577 GST_START_TEST (controller_interpolation_unset_all)
 578 {
 579   GstInterpolationControlSource *csource;
 580   GstTimedValueControlSource *tvcs;
 581   GstControlSource *cs;
 582   GstElement *elem;
 583
 584   elem = gst_element_factory_make ("testobj", NULL);
 585
 586   /* new interpolation control source */
 587   csource = gst_interpolation_control_source_new ();
 588   tvcs = (GstTimedValueControlSource *) csource;
 589   cs = (GstControlSource *) csource;
 590
 591   fail_unless (csource != NULL);
 592   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 593           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 594
 595   /* set interpolation mode */
 596   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_NONE, NULL);
 597
 598   /* set control values */
 599   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 600   fail_unless (gst_timed_value_control_source_set (tvcs, 1 * GST_SECOND, 1.0));
 601
 602   /* verify values */
 603   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 604   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 605   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 606   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 607
 608   /* unset all */
 609   gst_timed_value_control_source_unset_all (tvcs);
 610   GST_TEST_OBJ (elem)->val_int = 0;
 611
 612   /* verify value again */
 613   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 614   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 615
 616   gst_object_unref (csource);
 617   gst_object_unref (elem);
 618 }
 619
 620 GST_END_TEST;
 621
 622 /* test retrieval of an array of values with get_value_array() */
 623 GST_START_TEST (controller_interpolation_linear_value_array)
 624 {
 625   GstInterpolationControlSource *csource;
 626   GstTimedValueControlSource *tvcs;
 627   GstControlSource *cs;
 628   GstElement *elem;
 629   gdouble *raw_values;
 630   GValue *g_values;
 631
 632   elem = gst_element_factory_make ("testobj", NULL);
 633
 634   /* new interpolation control source */
 635   csource = gst_interpolation_control_source_new ();
 636   tvcs = (GstTimedValueControlSource *) csource;
 637   cs = (GstControlSource *) csource;
 638
 639   fail_unless (csource != NULL);
 640   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 641           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 642
 643   /* set interpolation mode */
 644   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 645
 646   /* set control values */
 647   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 648   fail_unless (gst_timed_value_control_source_set (tvcs, 1 * GST_SECOND, 1.0));
 649
 650   /* now pull in raw-values for some timestamps */
 651   raw_values = g_new (gdouble, 3);
 652
 653   fail_unless (gst_control_source_get_value_array (cs,
 654           0, GST_SECOND / 2, 3, raw_values));
 655   fail_unless_equals_float ((raw_values)[0], 0.0);
 656   fail_unless_equals_float ((raw_values)[1], 0.5);
 657   fail_unless_equals_float ((raw_values)[2], 1.0);
 658
 659   g_free (raw_values);
 660
 661   /* now pull in mapped values for some timestamps */
 662   g_values = g_new0 (GValue, 3);
 663
 664   fail_unless (gst_object_get_value_array (GST_OBJECT (elem), "int",
 665           0, GST_SECOND / 2, 3, g_values));
 666   fail_unless_equals_int (g_value_get_int (&g_values[0]), 0);
 667   fail_unless_equals_int (g_value_get_int (&g_values[1]), 50);
 668   fail_unless_equals_int (g_value_get_int (&g_values[2]), 100);
 669
 670   g_free (g_values);
 671
 672   gst_object_unref (csource);
 673   gst_object_unref (elem);
 674 }
 675
 676 GST_END_TEST;
 677
 678 /* test if values below minimum and above maximum are clipped */
 679 GST_START_TEST (controller_interpolation_linear_invalid_values)
 680 {
 681   GstInterpolationControlSource *csource;
 682   GstTimedValueControlSource *tvcs;
 683   GstControlSource *cs;
 684   GstElement *elem;
 685
 686   elem = gst_element_factory_make ("testobj", NULL);
 687
 688   /* new interpolation control source */
 689   csource = gst_interpolation_control_source_new ();
 690   tvcs = (GstTimedValueControlSource *) csource;
 691   cs = (GstControlSource *) csource;
 692
 693   fail_unless (csource != NULL);
 694   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 695           gst_control_binding_direct_new (GST_OBJECT (elem), "float", cs)));
 696
 697   /* set interpolation mode */
 698   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 699
 700   /* set control values */
 701   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 2.0));
 702   fail_unless (gst_timed_value_control_source_set (tvcs, 4 * GST_SECOND, -2.0));
 703
 704   /* now pull in values for some timestamps and see if clipping works */
 705   /* 200.0 */
 706   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 707   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_float, 100.0);
 708   /* 100.0 */
 709   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 710   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_float, 100.0);
 711   /* 50.0 */
 712   gst_object_sync_values (GST_OBJECT (elem),
 713       1 * GST_SECOND + 500 * GST_MSECOND);
 714   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_float, 50.0);
 715   /* 0.0 */
 716   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 717   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_float, 0.0);
 718   /* -100.0 */
 719   gst_object_sync_values (GST_OBJECT (elem), 3 * GST_SECOND);
 720   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_float, 0.0);
 721   /* -200.0 */
 722   gst_object_sync_values (GST_OBJECT (elem), 4 * GST_SECOND);
 723   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_float, 0.0);
 724
 725   gst_object_unref (csource);
 726   gst_object_unref (elem);
 727 }
 728
 729 GST_END_TEST;
 730
 731 GST_START_TEST (controller_interpolation_linear_default_values)
 732 {
 733   GstInterpolationControlSource *csource;
 734   GstTimedValueControlSource *tvcs;
 735   GstControlSource *cs;
 736   GstElement *elem;
 737
 738   elem = gst_element_factory_make ("testobj", NULL);
 739
 740   /* new interpolation control source */
 741   csource = gst_interpolation_control_source_new ();
 742   tvcs = (GstTimedValueControlSource *) csource;
 743   cs = (GstControlSource *) csource;
 744
 745   fail_unless (csource != NULL);
 746   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 747           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 748
 749   /* set interpolation mode */
 750   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 751
 752   /* Should fail if no value was set yet
 753    * FIXME: will not fail, as interpolation assumes val[0]=default_value if
 754    * nothing else is set.
 755    fail_if (gst_control_source_get_value (GST_CONTROL_SOURCE (csource),
 756    1 * GST_SECOND, &val_int));
 757    */
 758
 759   /* set control values */
 760   fail_unless (gst_timed_value_control_source_set (tvcs, 1 * GST_SECOND, 0.0));
 761   fail_unless (gst_timed_value_control_source_set (tvcs, 3 * GST_SECOND, 1.0));
 762
 763   /* now pull in values for some timestamps */
 764   /* should give the value of the first control point for timestamps before it */
 765   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 766   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 767   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 768   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 769   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 770   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 771   gst_object_sync_values (GST_OBJECT (elem), 3 * GST_SECOND);
 772   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 773
 774   /* set control values */
 775   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
 776   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 1.0));
 777
 778   /* unset the old ones */
 779   fail_unless (gst_timed_value_control_source_unset (tvcs, 1 * GST_SECOND));
 780   fail_unless (gst_timed_value_control_source_unset (tvcs, 3 * GST_SECOND));
 781
 782   /* now pull in values for some timestamps */
 783   /* should now give our value for timestamp 0 */
 784   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 785   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 786   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 787   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 788   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 789   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 790
 791   gst_object_unref (csource);
 792   gst_object_unref (elem);
 793 }
 794
 795 GST_END_TEST;
 796
 797 /* test gst_controller_set_disabled() with linear interpolation */
 798 GST_START_TEST (controller_interpolation_linear_disabled)
 799 {
 800   GstInterpolationControlSource *csource1, *csource2;
 801   GstTimedValueControlSource *tvcs1, *tvcs2;
 802   GstControlSource *cs1, *cs2;
 803   GstElement *elem;
 804
 805   elem = gst_element_factory_make ("testobj", NULL);
 806
 807   /* new interpolation control source */
 808   csource1 = gst_interpolation_control_source_new ();
 809   tvcs1 = (GstTimedValueControlSource *) csource1;
 810   cs1 = (GstControlSource *) csource1;
 811
 812   csource2 = gst_interpolation_control_source_new ();
 813   tvcs2 = (GstTimedValueControlSource *) csource2;
 814   cs2 = (GstControlSource *) csource2;
 815
 816   fail_unless (csource1 != NULL);
 817   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 818           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs1)));
 819   fail_unless (csource2 != NULL);
 820   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 821           gst_control_binding_direct_new (GST_OBJECT (elem), "double", cs2)));
 822
 823   /* set interpolation mode */
 824   g_object_set (csource1, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 825   g_object_set (csource2, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 826
 827   /* set control values */
 828   fail_unless (gst_timed_value_control_source_set (tvcs1, 0 * GST_SECOND, 0.0));
 829   fail_unless (gst_timed_value_control_source_set (tvcs1, 2 * GST_SECOND, 1.0));
 830
 831   /* set control values */
 832   fail_unless (gst_timed_value_control_source_set (tvcs2, 0 * GST_SECOND, 0.2));
 833   fail_unless (gst_timed_value_control_source_set (tvcs2, 2 * GST_SECOND, 0.4));
 834
 835   /* now pull in values for some timestamps */
 836   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 837   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 838   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 20.0);
 839   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 840   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 841   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 30.0);
 842   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 843   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 844   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 40.0);
 845
 846   /* now pull in values for some timestamps, prop double disabled */
 847   GST_TEST_OBJ (elem)->val_int = 0;
 848   GST_TEST_OBJ (elem)->val_double = 0.0;
 849   gst_object_set_control_binding_disabled (GST_OBJECT (elem), "double", TRUE);
 850   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 851   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 852   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 853   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 854   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 855   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 856   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 857   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 858   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 859
 860   /* now pull in values for some timestamps, after enabling double again */
 861   GST_TEST_OBJ (elem)->val_int = 0;
 862   GST_TEST_OBJ (elem)->val_double = 0.0;
 863   gst_object_set_control_binding_disabled (GST_OBJECT (elem), "double", FALSE);
 864   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 865   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 866   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 20.0);
 867   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 868   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 869   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 30.0);
 870   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 871   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 872   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 40.0);
 873
 874   /* now pull in values for some timestamps, after disabling all props */
 875   GST_TEST_OBJ (elem)->val_int = 0;
 876   GST_TEST_OBJ (elem)->val_double = 0.0;
 877   gst_object_set_control_bindings_disabled (GST_OBJECT (elem), TRUE);
 878   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 879   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 880   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 881   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 882   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 883   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 884   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 885   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 886   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 0.0);
 887
 888   /* now pull in values for some timestamps, enabling double again */
 889   GST_TEST_OBJ (elem)->val_int = 0;
 890   GST_TEST_OBJ (elem)->val_double = 0.0;
 891   gst_object_set_control_binding_disabled (GST_OBJECT (elem), "double", FALSE);
 892   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 893   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 894   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 20.0);
 895   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 896   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 897   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 30.0);
 898   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 899   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 900   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 40.0);
 901
 902   /* now pull in values for some timestamps, enabling all */
 903   GST_TEST_OBJ (elem)->val_int = 0;
 904   GST_TEST_OBJ (elem)->val_double = 0.0;
 905   gst_object_set_control_bindings_disabled (GST_OBJECT (elem), FALSE);
 906   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
 907   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
 908   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 20.0);
 909   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
 910   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
 911   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 30.0);
 912   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 913   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
 914   fail_unless_equals_float (GST_TEST_OBJ (elem)->val_double, 40.0);
 915
 916   gst_object_unref (csource1);
 917   gst_object_unref (csource2);
 918   gst_object_unref (elem);
 919 }
 920
 921 GST_END_TEST;
 922
 923
 924 GST_START_TEST (controller_interpolation_set_from_list)
 925 {
 926   GstInterpolationControlSource *csource;
 927   GstTimedValueControlSource *tvcs;
 928   GstControlSource *cs;
 929   GstTimedValue *tval;
 930   GstElement *elem;
 931   GSList *list = NULL;
 932
 933   /* test that an invalid timestamp throws a warning of some sort */
 934   elem = gst_element_factory_make ("testobj", NULL);
 935
 936   /* new interpolation control source */
 937   csource = gst_interpolation_control_source_new ();
 938   tvcs = (GstTimedValueControlSource *) csource;
 939   cs = (GstControlSource *) csource;
 940
 941   fail_unless (csource != NULL);
 942   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 943           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 944
 945   /* set interpolation mode */
 946   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 947
 948   /* set control value */
 949   tval = g_new0 (GstTimedValue, 1);
 950   tval->timestamp = GST_CLOCK_TIME_NONE;
 951   tval->value = 0.0;
 952
 953   list = g_slist_append (list, tval);
 954
 955   fail_if (gst_timed_value_control_source_set_from_list (tvcs, list));
 956
 957   /* try again with a valid stamp, should work now */
 958   tval->timestamp = 0;
 959   fail_unless (gst_timed_value_control_source_set_from_list (tvcs, list));
 960
 961   /* allocated GstTimedValue now belongs to the controller, but list not */
 962   g_free (tval);
 963   g_slist_free (list);
 964   gst_object_unref (csource);
 965   gst_object_unref (elem);
 966 }
 967
 968 GST_END_TEST;
 969
 970
 971 /* test linear interpolation for ts < first control point */
 972 GST_START_TEST (controller_interpolation_linear_before_ts0)
 973 {
 974   GstInterpolationControlSource *csource;
 975   GstTimedValueControlSource *tvcs;
 976   GstControlSource *cs;
 977   GstElement *elem;
 978
 979   elem = gst_element_factory_make ("testobj", NULL);
 980
 981   /* new interpolation control source */
 982   csource = gst_interpolation_control_source_new ();
 983   tvcs = (GstTimedValueControlSource *) csource;
 984   cs = (GstControlSource *) csource;
 985
 986   fail_unless (csource != NULL);
 987   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
 988           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
 989
 990   /* set interpolation mode */
 991   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
 992
 993   /* set control values */
 994   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 1.0));
 995   fail_unless (gst_timed_value_control_source_set (tvcs, 4 * GST_SECOND, 0.0));
 996
 997   /* now pull in values for some timestamps after first control point */
 998   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
 999   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1000   gst_object_sync_values (GST_OBJECT (elem), 3 * GST_SECOND);
1001   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1002   gst_object_sync_values (GST_OBJECT (elem), 4 * GST_SECOND);
1003   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1004
1005   /* now pull in values for some timestamps before first control point */
1006   GST_TEST_OBJ (elem)->val_int = 25;
1007   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
1008   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1009   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
1010   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1011
1012   gst_object_unref (csource);
1013   gst_object_unref (elem);
1014 }
1015
1016 GST_END_TEST;
1017
1018 /* test linear interpolation of enums */
1019 GST_START_TEST (controller_interpolation_linear_enums)
1020 {
1021   GstInterpolationControlSource *csource;
1022   GstTimedValueControlSource *tvcs;
1023   GstControlSource *cs;
1024   GstElement *elem;
1025
1026   elem = gst_element_factory_make ("testobj", NULL);
1027
1028   /* new interpolation control source */
1029   csource = gst_interpolation_control_source_new ();
1030   tvcs = (GstTimedValueControlSource *) csource;
1031   cs = (GstControlSource *) csource;
1032
1033   fail_unless (csource != NULL);
1034   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1035           gst_control_binding_direct_new (GST_OBJECT (elem), "enum", cs)));
1036
1037   /* set interpolation mode */
1038   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL);
1039
1040   /* set control values */
1041   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
1042   fail_unless (gst_timed_value_control_source_set (tvcs, 4 * GST_SECOND, 1.0));
1043
1044   /* now pull in values going over the enum values */
1045   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
1046   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_enum, ENUM_V0);
1047   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
1048   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_enum, ENUM_V10);
1049   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
1050   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_enum, ENUM_V11);
1051   gst_object_sync_values (GST_OBJECT (elem), 3 * GST_SECOND);
1052   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_enum, ENUM_V12);
1053   gst_object_sync_values (GST_OBJECT (elem), 4 * GST_SECOND);
1054   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_enum, ENUM_V255);
1055
1056   gst_object_unref (csource);
1057   gst_object_unref (elem);
1058 }
1059
1060 GST_END_TEST;
1061
1062 /* test timed value counts */
1063 GST_START_TEST (controller_timed_value_count)
1064 {
1065   GstInterpolationControlSource *csource;
1066   GstTimedValueControlSource *tvcs;
1067   GstControlSource *cs;
1068   GstElement *elem;
1069
1070   elem = gst_element_factory_make ("testobj", NULL);
1071
1072   /* new interpolation control source */
1073   csource = gst_interpolation_control_source_new ();
1074   tvcs = (GstTimedValueControlSource *) csource;
1075   cs = (GstControlSource *) csource;
1076
1077   fail_unless (csource != NULL);
1078   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1079           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1080
1081   /* set interpolation mode */
1082   g_object_set (csource, "mode", GST_INTERPOLATION_MODE_NONE, NULL);
1083
1084   fail_unless (gst_timed_value_control_source_get_count (tvcs) == 0);
1085
1086   /* set control values */
1087   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.0));
1088   fail_unless (gst_timed_value_control_source_get_count (tvcs) == 1);
1089   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 1.0));
1090   fail_unless (gst_timed_value_control_source_get_count (tvcs) == 2);
1091
1092   /* unset control values */
1093   fail_unless (gst_timed_value_control_source_unset (tvcs, 2 * GST_SECOND));
1094   fail_unless (gst_timed_value_control_source_get_count (tvcs) == 1);
1095   fail_unless (gst_timed_value_control_source_unset (tvcs, 0 * GST_SECOND));
1096   fail_unless (gst_timed_value_control_source_get_count (tvcs) == 0);
1097
1098   gst_object_unref (csource);
1099   gst_object_unref (elem);
1100 }
1101
1102 GST_END_TEST;
1103
1104
1105 /* test lfo control source with sine waveform */
1106 GST_START_TEST (controller_lfo_sine)
1107 {
1108   GstLFOControlSource *csource;
1109   GstControlSource *cs;
1110   GstElement *elem;
1111
1112   elem = gst_element_factory_make ("testobj", NULL);
1113
1114   /* new lfo control source */
1115   csource = gst_lfo_control_source_new ();
1116   cs = (GstControlSource *) csource;
1117
1118   fail_unless (csource != NULL);
1119   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1120           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1121
1122   /* configure lfo */
1123   g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SINE,
1124       "frequency", 1.0, "timeshift", (GstClockTime) 0,
1125       "amplitude", 0.5, "offset", 0.5, NULL);
1126
1127   /* now pull in values for some timestamps */
1128   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_MSECOND);
1129   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1130   gst_object_sync_values (GST_OBJECT (elem), 250 * GST_MSECOND);
1131   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1132   gst_object_sync_values (GST_OBJECT (elem), 500 * GST_MSECOND);
1133   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1134   gst_object_sync_values (GST_OBJECT (elem), 750 * GST_MSECOND);
1135   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1136   gst_object_sync_values (GST_OBJECT (elem), 1000 * GST_MSECOND);
1137   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1138   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1139   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1140   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1141   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1142   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1143   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1144   gst_object_sync_values (GST_OBJECT (elem), 2000 * GST_MSECOND);
1145   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1146   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1147   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1148   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1149   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1150   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1151   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1152
1153   gst_object_unref (csource);
1154   gst_object_unref (elem);
1155 }
1156
1157 GST_END_TEST;
1158
1159 /* test lfo control source with sine waveform and timeshift */
1160 GST_START_TEST (controller_lfo_sine_timeshift)
1161 {
1162   GstLFOControlSource *csource;
1163   GstControlSource *cs;
1164   GstElement *elem;
1165
1166   elem = gst_element_factory_make ("testobj", NULL);
1167
1168   /* new lfo control source */
1169   csource = gst_lfo_control_source_new ();
1170   cs = (GstControlSource *) csource;
1171
1172   fail_unless (csource != NULL);
1173   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1174           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1175
1176   /* configure lfo */
1177   g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SINE,
1178       "frequency", 1.0, "timeshift", 250 * GST_MSECOND,
1179       "amplitude", 0.5, "offset", 0.5, NULL);
1180
1181   /* now pull in values for some timestamps */
1182   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_MSECOND);
1183   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1184   gst_object_sync_values (GST_OBJECT (elem), 250 * GST_MSECOND);
1185   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1186   gst_object_sync_values (GST_OBJECT (elem), 500 * GST_MSECOND);
1187   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1188   gst_object_sync_values (GST_OBJECT (elem), 750 * GST_MSECOND);
1189   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1190   gst_object_sync_values (GST_OBJECT (elem), 1000 * GST_MSECOND);
1191   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1192   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1193   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1194   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1195   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1196   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1197   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1198   gst_object_sync_values (GST_OBJECT (elem), 2000 * GST_MSECOND);
1199   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1200   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1201   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1202   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1203   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1204   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1205   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1206
1207   gst_object_unref (csource);
1208   gst_object_unref (elem);
1209 }
1210
1211 GST_END_TEST;
1212
1213 /* test lfo control source with square waveform */
1214 GST_START_TEST (controller_lfo_square)
1215 {
1216   GstLFOControlSource *csource;
1217   GstControlSource *cs;
1218   GstElement *elem;
1219
1220   elem = gst_element_factory_make ("testobj", NULL);
1221
1222   /* new lfo control source */
1223   csource = gst_lfo_control_source_new ();
1224   cs = (GstControlSource *) csource;
1225
1226   fail_unless (csource != NULL);
1227   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1228           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1229
1230   /* configure lfo */
1231   g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SQUARE,
1232       "frequency", 1.0, "timeshift", (GstClockTime) 0,
1233       "amplitude", 0.5, "offset", 0.5, NULL);
1234
1235   /* now pull in values for some timestamps */
1236   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_MSECOND);
1237   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1238   gst_object_sync_values (GST_OBJECT (elem), 250 * GST_MSECOND);
1239   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1240   gst_object_sync_values (GST_OBJECT (elem), 500 * GST_MSECOND);
1241   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1242   gst_object_sync_values (GST_OBJECT (elem), 750 * GST_MSECOND);
1243   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1244   gst_object_sync_values (GST_OBJECT (elem), 1000 * GST_MSECOND);
1245   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1246   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1247   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1248   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1249   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1250   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1251   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1252   gst_object_sync_values (GST_OBJECT (elem), 2000 * GST_MSECOND);
1253   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1254   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1255   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1256   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1257   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1258   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1259   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1260
1261   gst_object_unref (csource);
1262   gst_object_unref (elem);
1263 }
1264
1265 GST_END_TEST;
1266
1267 /* test lfo control source with saw waveform */
1268 GST_START_TEST (controller_lfo_saw)
1269 {
1270   GstLFOControlSource *csource;
1271   GstControlSource *cs;
1272   GstElement *elem;
1273
1274   elem = gst_element_factory_make ("testobj", NULL);
1275
1276   /* new lfo control source */
1277   csource = gst_lfo_control_source_new ();
1278   cs = (GstControlSource *) csource;
1279
1280   fail_unless (csource != NULL);
1281   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1282           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1283
1284   /* configure lfo */
1285   g_object_set (csource, "waveform", GST_LFO_WAVEFORM_SAW,
1286       "frequency", 1.0, "timeshift", (GstClockTime) 0,
1287       "amplitude", 0.5, "offset", 0.5, NULL);
1288
1289   /* now pull in values for some timestamps */
1290   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_MSECOND);
1291   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1292   gst_object_sync_values (GST_OBJECT (elem), 250 * GST_MSECOND);
1293   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 75);
1294   gst_object_sync_values (GST_OBJECT (elem), 500 * GST_MSECOND);
1295   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1296   gst_object_sync_values (GST_OBJECT (elem), 750 * GST_MSECOND);
1297   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1298   gst_object_sync_values (GST_OBJECT (elem), 1000 * GST_MSECOND);
1299   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1300   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1301   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 75);
1302   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1303   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1304   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1305   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1306   gst_object_sync_values (GST_OBJECT (elem), 2000 * GST_MSECOND);
1307   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1308   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1309   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 75);
1310   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1311   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1312   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1313   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1314
1315   gst_object_unref (csource);
1316   gst_object_unref (elem);
1317 }
1318
1319 GST_END_TEST;
1320
1321 /* test lfo control source with reverse saw waveform */
1322 GST_START_TEST (controller_lfo_rsaw)
1323 {
1324   GstLFOControlSource *csource;
1325   GstControlSource *cs;
1326   GstElement *elem;
1327
1328   elem = gst_element_factory_make ("testobj", NULL);
1329
1330   /* new lfo control source */
1331   csource = gst_lfo_control_source_new ();
1332   cs = (GstControlSource *) csource;
1333
1334   fail_unless (csource != NULL);
1335   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1336           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1337
1338   /* configure lfo */
1339   g_object_set (csource, "waveform", GST_LFO_WAVEFORM_REVERSE_SAW,
1340       "frequency", 1.0, "timeshift", (GstClockTime) 0,
1341       "amplitude", 0.5, "offset", 0.5, NULL);
1342
1343   /* now pull in values for some timestamps */
1344   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_MSECOND);
1345   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1346   gst_object_sync_values (GST_OBJECT (elem), 250 * GST_MSECOND);
1347   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1348   gst_object_sync_values (GST_OBJECT (elem), 500 * GST_MSECOND);
1349   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1350   gst_object_sync_values (GST_OBJECT (elem), 750 * GST_MSECOND);
1351   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 75);
1352   gst_object_sync_values (GST_OBJECT (elem), 1000 * GST_MSECOND);
1353   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1354   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1355   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1356   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1357   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1358   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1359   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 75);
1360   gst_object_sync_values (GST_OBJECT (elem), 2000 * GST_MSECOND);
1361   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1362   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1363   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 25);
1364   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1365   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1366   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1367   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 75);
1368
1369   gst_object_unref (csource);
1370   gst_object_unref (elem);
1371 }
1372
1373 GST_END_TEST;
1374
1375 /* test lfo control source with saw waveform */
1376 GST_START_TEST (controller_lfo_triangle)
1377 {
1378   GstLFOControlSource *csource;
1379   GstControlSource *cs;
1380   GstElement *elem;
1381
1382   elem = gst_element_factory_make ("testobj", NULL);
1383
1384   /* new lfo control source */
1385   csource = gst_lfo_control_source_new ();
1386   cs = (GstControlSource *) csource;
1387
1388   fail_unless (csource != NULL);
1389   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1390           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1391
1392   /* configure lfo */
1393   g_object_set (csource, "waveform", GST_LFO_WAVEFORM_TRIANGLE,
1394       "frequency", 1.0, "timeshift", (GstClockTime) 0,
1395       "amplitude", 0.5, "offset", 0.5, NULL);
1396
1397   /* now pull in values for some timestamps */
1398   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_MSECOND);
1399   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1400   gst_object_sync_values (GST_OBJECT (elem), 250 * GST_MSECOND);
1401   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1402   gst_object_sync_values (GST_OBJECT (elem), 500 * GST_MSECOND);
1403   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1404   gst_object_sync_values (GST_OBJECT (elem), 750 * GST_MSECOND);
1405   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1406   gst_object_sync_values (GST_OBJECT (elem), 1000 * GST_MSECOND);
1407   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1408   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1409   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1410   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1411   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1412   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1413   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1414   gst_object_sync_values (GST_OBJECT (elem), 2000 * GST_MSECOND);
1415   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1416   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1417   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1418   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1419   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1420   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1421   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1422
1423   gst_object_unref (csource);
1424   gst_object_unref (elem);
1425 }
1426
1427 GST_END_TEST;
1428
1429 /* test lfo control source with nothing set */
1430 GST_START_TEST (controller_lfo_none)
1431 {
1432   GstLFOControlSource *csource;
1433   GstControlSource *cs;
1434   GstElement *elem;
1435
1436   elem = gst_element_factory_make ("testobj", NULL);
1437
1438   /* new lfo control source */
1439   csource = gst_lfo_control_source_new ();
1440   cs = (GstControlSource *) csource;
1441
1442   fail_unless (csource != NULL);
1443   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1444           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1445
1446   /* now pull in values for some timestamps */
1447   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_MSECOND);
1448   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1449   gst_object_sync_values (GST_OBJECT (elem), 250 * GST_MSECOND);
1450   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1451   gst_object_sync_values (GST_OBJECT (elem), 500 * GST_MSECOND);
1452   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1453   gst_object_sync_values (GST_OBJECT (elem), 750 * GST_MSECOND);
1454   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1455   gst_object_sync_values (GST_OBJECT (elem), 1000 * GST_MSECOND);
1456   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1457   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1458   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1459   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1460   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1461   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1462   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1463   gst_object_sync_values (GST_OBJECT (elem), 2000 * GST_MSECOND);
1464   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1465   gst_object_sync_values (GST_OBJECT (elem), 1250 * GST_MSECOND);
1466   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1467   gst_object_sync_values (GST_OBJECT (elem), 1500 * GST_MSECOND);
1468   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1469   gst_object_sync_values (GST_OBJECT (elem), 1750 * GST_MSECOND);
1470   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1471
1472   gst_object_unref (csource);
1473   gst_object_unref (elem);
1474 }
1475
1476 GST_END_TEST;
1477
1478 /* test timed value handling in trigger mode */
1479 GST_START_TEST (controller_trigger_exact)
1480 {
1481   GstTriggerControlSource *csource;
1482   GstControlSource *cs;
1483   GstTimedValueControlSource *tvcs;
1484   GstElement *elem;
1485   gdouble raw_val;
1486
1487   elem = gst_element_factory_make ("testobj", NULL);
1488
1489   /* new interpolation control source */
1490   csource = gst_trigger_control_source_new ();
1491   tvcs = (GstTimedValueControlSource *) csource;
1492   cs = (GstControlSource *) csource;
1493
1494   fail_unless (csource != NULL);
1495   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1496           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1497
1498   fail_if (gst_control_source_get_value (cs, 0 * GST_SECOND, &raw_val));
1499
1500   /* set control values */
1501   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.5));
1502   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 1.0));
1503
1504   /* now pull in values for some timestamps */
1505   fail_unless (gst_control_source_get_value (cs, 0 * GST_SECOND, &raw_val));
1506
1507   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
1508   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1509
1510   GST_TEST_OBJ (elem)->val_int = 0;
1511   fail_if (gst_control_source_get_value (cs, 1 * GST_SECOND, &raw_val));
1512   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
1513   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1514
1515   fail_unless (gst_control_source_get_value (cs, 2 * GST_SECOND, &raw_val));
1516   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
1517   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1518
1519   gst_object_unref (csource);
1520   gst_object_unref (elem);
1521 }
1522
1523 GST_END_TEST;
1524
1525 GST_START_TEST (controller_trigger_tolerance)
1526 {
1527   GstTriggerControlSource *csource;
1528   GstControlSource *cs;
1529   GstTimedValueControlSource *tvcs;
1530   GstElement *elem;
1531   gdouble raw_val;
1532
1533   elem = gst_element_factory_make ("testobj", NULL);
1534
1535   /* new interpolation control source */
1536   csource = gst_trigger_control_source_new ();
1537   tvcs = (GstTimedValueControlSource *) csource;
1538   cs = (GstControlSource *) csource;
1539
1540   fail_unless (csource != NULL);
1541   fail_unless (gst_object_add_control_binding (GST_OBJECT (elem),
1542           gst_control_binding_direct_new (GST_OBJECT (elem), "int", cs)));
1543
1544   g_object_set (csource, "tolerance", G_GINT64_CONSTANT (10), NULL);
1545
1546   fail_if (gst_control_source_get_value (cs, 0 * GST_SECOND, &raw_val));
1547
1548   /* set control values */
1549   fail_unless (gst_timed_value_control_source_set (tvcs, 0 * GST_SECOND, 0.5));
1550   fail_unless (gst_timed_value_control_source_set (tvcs, 2 * GST_SECOND, 1.0));
1551
1552   /* now pull in values for some timestamps */
1553   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND);
1554   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1555   gst_object_sync_values (GST_OBJECT (elem), 0 * GST_SECOND + 5);
1556   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 50);
1557
1558   GST_TEST_OBJ (elem)->val_int = 0;
1559   gst_object_sync_values (GST_OBJECT (elem), 1 * GST_SECOND);
1560   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 0);
1561
1562   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND - 5);
1563   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1564   gst_object_sync_values (GST_OBJECT (elem), 2 * GST_SECOND);
1565   fail_unless_equals_int (GST_TEST_OBJ (elem)->val_int, 100);
1566
1567   gst_object_unref (csource);
1568   gst_object_unref (elem);
1569 }
1570
1571 GST_END_TEST;
1572
1573
1574 static Suite *
1575 gst_controller_suite (void)
1576 {
1577   Suite *s = suite_create ("Controller");
1578   TCase *tc = tcase_create ("general");
1579
1580   suite_add_tcase (s, tc);
1581   tcase_add_checked_fixture (tc, setup, teardown);
1582   tcase_add_test (tc, controller_controlsource_empty1);
1583   tcase_add_test (tc, controller_controlsource_empty2);
1584   tcase_add_test (tc, controller_interpolation_none);
1585   tcase_add_test (tc, controller_interpolation_linear);
1586   tcase_add_test (tc, controller_interpolation_cubic);
1587   tcase_add_test (tc, controller_interpolation_cubic_too_few_cp);
1588   tcase_add_test (tc, controller_interpolation_unset);
1589   tcase_add_test (tc, controller_interpolation_unset_all);
1590   tcase_add_test (tc, controller_interpolation_linear_value_array);
1591   tcase_add_test (tc, controller_interpolation_linear_invalid_values);
1592   tcase_add_test (tc, controller_interpolation_linear_default_values);
1593   tcase_add_test (tc, controller_interpolation_linear_disabled);
1594   tcase_add_test (tc, controller_interpolation_set_from_list);
1595   tcase_add_test (tc, controller_interpolation_linear_before_ts0);
1596   tcase_add_test (tc, controller_interpolation_linear_enums);
1597   tcase_add_test (tc, controller_timed_value_count);
1598   tcase_add_test (tc, controller_lfo_sine);
1599   tcase_add_test (tc, controller_lfo_sine_timeshift);
1600   tcase_add_test (tc, controller_lfo_square);
1601   tcase_add_test (tc, controller_lfo_saw);
1602   tcase_add_test (tc, controller_lfo_rsaw);
1603   tcase_add_test (tc, controller_lfo_triangle);
1604   tcase_add_test (tc, controller_lfo_none);
1605   tcase_add_test (tc, controller_trigger_exact);
1606   tcase_add_test (tc, controller_trigger_tolerance);
1607
1608   return s;
1609 }
1610
1611 GST_CHECK_MAIN (gst_controller);