libs/gst/control/dparammanager.c

   1 /* GStreamer
   2  * Copyright (C) 2001 Steve Baker <stevebaker_org@yahoo.co.uk>
   3  *
   4  * gstdparammanager.c: Dynamic Parameter group functionality
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <gst/control/dparammanager.h>
  23 #include <gst/gstelement.h>
  24 #include <gst/gstinfo.h>
  25
  26 static GHashTable *_element_registry;
  27
  28 static void gst_dpman_class_init (GstDParamManagerClass *klass);
  29 static void gst_dpman_init (GstDParamManager *dpman);
  30 static void gst_dpman_dispose (GObject *object);
  31  static GstDParamWrapper* gst_dpman_new_wrapper(GstDParamManager *dpman, GParamSpec *param_spec, gboolean is_log, gboolean is_rate, GstDPMUpdateMethod update_method);
  32  static GstDParamWrapper* gst_dpman_get_wrapper(GstDParamManager *dpman, gchar *dparam_name);
  33 static void gst_dpman_state_change (GstElement *element, gint old_state, gint new_state, GstDParamManager *dpman);
  34 static void gst_dpman_caps_changed (GstPad *pad, GstCaps *caps, GstDParamManager *dpman);
  35 static guint gst_dpman_preprocess_synchronous(GstDParamManager *dpman, guint frames, gint64 timestamp);
  36 static guint gst_dpman_preprocess_noop(GstDParamManager *dpman, guint frames, gint64 timestamp);
  37 static guint gst_dpman_process_noop(GstDParamManager *dpman, guint frame_count);
  38
  39 static GObjectClass *parent_class;
  40
  41 void
  42 _gst_dpman_initialize()
  43 {
  44 }
  45
  46 GType
  47 gst_dpman_get_type (void)
  48 {
  49         static GType dpman_type = 0;
  50
  51         if (!dpman_type) {
  52                 static const GTypeInfo dpman_info = {
  53                         sizeof(GstDParamManagerClass),
  54                         NULL,
  55                         NULL,
  56                         (GClassInitFunc)gst_dpman_class_init,
  57                         NULL,
  58                         NULL,
  59                         sizeof(GstDParamManager),
  60                         0,
  61                         (GInstanceInitFunc)gst_dpman_init,
  62                 };
  63                 dpman_type = g_type_register_static(GST_TYPE_OBJECT, "GstDParamManager", &dpman_info, 0);
  64         }
  65         return dpman_type;
  66 }
  67
  68 static void
  69 gst_dpman_class_init (GstDParamManagerClass *klass)
  70 {
  71         GstObjectClass *gstobject_class;
  72         GObjectClass *gobject_class;
  73
  74         parent_class = g_type_class_peek_parent (klass);
  75
  76         gstobject_class = (GstObjectClass*) klass;
  77         gobject_class = (GObjectClass*) klass;
  78         gobject_class->dispose = gst_dpman_dispose;
  79
  80         klass->modes = g_hash_table_new(g_str_hash,g_str_equal);
  81
  82         gst_dpman_register_mode (klass, "synchronous",
  83                                gst_dpman_preprocess_synchronous, gst_dpman_process_noop, NULL, NULL);
  84         gst_dpman_register_mode (klass, "asynchronous",
  85                                gst_dpman_preprocess_noop, gst_dpman_process_noop, NULL, NULL);
  86         gst_dpman_register_mode (klass, "disabled",
  87                                gst_dpman_preprocess_noop, gst_dpman_process_noop, NULL, NULL);
  88
  89         _element_registry = g_hash_table_new(NULL,NULL);
  90 }
  91
  92 static void
  93 gst_dpman_init (GstDParamManager *dpman)
  94 {
  95         GST_DPMAN_DPARAMS(dpman) = g_hash_table_new(g_str_hash,g_str_equal);
  96         GST_DPMAN_DPARAMS_LIST(dpman) = NULL;
  97         GST_DPMAN_NAME(dpman) = NULL;
  98         GST_DPMAN_PARENT(dpman) = NULL;
  99         GST_DPMAN_MODE_NAME(dpman) = NULL;
 100         GST_DPMAN_MODE(dpman) = NULL;
 101         GST_DPMAN_MODE_DATA(dpman) = NULL;
 102         GST_DPMAN_RATE(dpman) = 0;
 103 }
 104
 105 /**
 106  * gst_dpman_new:
 107  * @name: name of the GstDParamManager instance
 108  * @parent: element which created this instance
 109  *
 110  * Returns: a new instance of GstDParamManager
 111  */
 112 GstDParamManager*
 113 gst_dpman_new (gchar *name, GstElement *parent)
 114 {
 115         GstDParamManager *dpman;
 116
 117         g_return_val_if_fail (name != NULL, NULL);
 118
 119         dpman = g_object_new (gst_dpman_get_type (), NULL);
 120         gst_object_set_name (GST_OBJECT (dpman), name);
 121         gst_dpman_set_parent(dpman, parent);
 122
 123         gst_dpman_set_mode(dpman, "disabled");
 124
 125         return dpman;
 126 }
 127
 128
 129 static void
 130 gst_dpman_dispose (GObject *object)
 131 {
 132 /*      GstDParamManager *dpman = GST_DPMAN(object); */
 133
 134         G_OBJECT_CLASS (parent_class)->dispose (object);
 135 }
 136
 137 /**
 138  * gst_dpman_add_required_dparam_callback:
 139  * @dpman: GstDParamManager instance
 140  * @update_func: callback to update the element with the new value
 141  * @update_data: will be included in the call to update_func
 142  *
 143  * Returns: true if it was successfully added
 144  */
 145 gboolean
 146 gst_dpman_add_required_dparam_callback (GstDParamManager *dpman,
 147                                         GParamSpec *param_spec,
 148                                         gboolean is_log,
 149                                         gboolean is_rate,
 150                                         GstDPMUpdateFunction update_func,
 151                                         gpointer update_data)
 152 {
 153         GstDParamWrapper* dpwrap;
 154
 155         g_return_val_if_fail (dpman != NULL, FALSE);
 156         g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
 157         g_return_val_if_fail (update_func != NULL, FALSE);
 158
 159         dpwrap = gst_dpman_new_wrapper(dpman, param_spec, is_log, is_rate, GST_DPMAN_CALLBACK);
 160
 161         g_return_val_if_fail (dpwrap != NULL, FALSE);
 162
 163         GST_DEBUG(GST_CAT_PARAMS,"adding required callback dparam '%s'", g_param_spec_get_name(param_spec));
 164
 165         dpwrap->update_func = update_func;
 166         dpwrap->update_data = update_data;
 167
 168         return TRUE;
 169 }
 170
 171 /**
 172  * gst_dpman_add_required_dparam_direct:
 173  * @dpman: GstDParamManager instance
 174  * @update_data: pointer to the member to be updated
 175  *
 176  * Returns: true if it was successfully added
 177  */
 178 gboolean
 179 gst_dpman_add_required_dparam_direct (GstDParamManager *dpman,
 180                                       GParamSpec *param_spec,
 181                                       gboolean is_log,
 182                                       gboolean is_rate,
 183                                       gpointer update_data)
 184 {
 185         GstDParamWrapper* dpwrap;
 186
 187         g_return_val_if_fail (dpman != NULL, FALSE);
 188         g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
 189         g_return_val_if_fail (update_data != NULL, FALSE);
 190
 191         dpwrap = gst_dpman_new_wrapper(dpman, param_spec, is_log, is_rate, GST_DPMAN_DIRECT);
 192
 193         g_return_val_if_fail (dpwrap != NULL, FALSE);
 194
 195         GST_DEBUG(GST_CAT_PARAMS,"adding required direct dparam '%s'", g_param_spec_get_name(param_spec));
 196
 197         dpwrap->update_data = update_data;
 198
 199         return TRUE;
 200 }
 201
 202 /**
 203  * gst_dpman_add_required_dparam_array:
 204  * @dpman: GstDParamManager instance
 205  * @dparam_name: a parameter name unique to this GstDParamManager
 206  * @update_data: pointer to where the array will be stored
 207  *
 208  * Returns: true if it was successfully added
 209  */
 210 gboolean
 211 gst_dpman_add_required_dparam_array (GstDParamManager *dpman,
 212                                      GParamSpec *param_spec,
 213                                      gboolean is_log,
 214                                      gboolean is_rate,
 215                                      gpointer update_data)
 216 {
 217         GstDParamWrapper* dpwrap;
 218
 219         g_return_val_if_fail (dpman != NULL, FALSE);
 220         g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
 221         g_return_val_if_fail (update_data != NULL, FALSE);
 222
 223         dpwrap = gst_dpman_new_wrapper(dpman, param_spec, is_log, is_rate, GST_DPMAN_ARRAY);
 224
 225         g_return_val_if_fail (dpwrap != NULL, FALSE);
 226
 227         GST_DEBUG(GST_CAT_PARAMS,"adding required array dparam '%s'", g_param_spec_get_name(param_spec));
 228
 229         dpwrap->update_data = update_data;
 230
 231         return TRUE;
 232 }
 233
 234 /**
 235  * gst_dpman_remove_required_dparam:
 236  * @dpman: GstDParamManager instance
 237  * @dparam_name: the name of an existing parameter
 238  *
 239  */
 240 void
 241 gst_dpman_remove_required_dparam (GstDParamManager *dpman, gchar *dparam_name)
 242 {
 243         GstDParamWrapper* dpwrap;
 244
 245         g_return_if_fail (dpman != NULL);
 246         g_return_if_fail (GST_IS_DPMAN (dpman));
 247         g_return_if_fail (dparam_name != NULL);
 248
 249         dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
 250
 251         g_return_if_fail(dpwrap != NULL);
 252         g_return_if_fail(dpwrap->dparam == NULL);
 253
 254         GST_DEBUG(GST_CAT_PARAMS, "removing required dparam: %s", dparam_name);
 255
 256         g_hash_table_remove(GST_DPMAN_DPARAMS(dpman), dparam_name);
 257         GST_DPMAN_DPARAMS_LIST(dpman) = g_slist_remove(GST_DPMAN_DPARAMS_LIST(dpman), dpwrap);
 258
 259         g_free(dpwrap->value);
 260         g_free(dpwrap);
 261 }
 262
 263 /**
 264  * gst_dpman_attach_dparam:
 265  * @dpman: GstDParamManager instance
 266  * @dparam_name: a name previously added with gst_dpman_add_required_dparam
 267  * @dparam: GstDParam instance to attach
 268  *
 269  * Returns: true if it was successfully attached
 270  */
 271 gboolean
 272 gst_dpman_attach_dparam (GstDParamManager *dpman, gchar *dparam_name, GstDParam *dparam)
 273 {
 274         GstDParamWrapper* dpwrap;
 275
 276         g_return_val_if_fail (dpman != NULL, FALSE);
 277         g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
 278         g_return_val_if_fail (dparam_name != NULL, FALSE);
 279         g_return_val_if_fail (dparam != NULL, FALSE);
 280         g_return_val_if_fail (GST_IS_DPARAM (dparam), FALSE);
 281         g_return_val_if_fail (dparam != NULL, FALSE);
 282
 283         dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
 284
 285         g_return_val_if_fail(dpwrap != NULL, FALSE);
 286         g_return_val_if_fail(dpwrap->value != NULL, FALSE);
 287
 288         dpwrap->dparam = dparam;
 289         gst_dparam_attach(dparam, dpman, dpwrap->param_spec, dpwrap->is_log, dpwrap->is_rate);
 290
 291         return TRUE;
 292 }
 293
 294 /**
 295  * gst_dpman_detach_dparam:
 296  * @dpman: GstDParamManager instance
 297  * @dparam_name: the name of a parameter with a previously attached GstDParam
 298  *
 299  */
 300 void
 301 gst_dpman_detach_dparam (GstDParamManager *dpman, gchar *dparam_name)
 302 {
 303         GstDParamWrapper* dpwrap;
 304
 305         g_return_if_fail (dpman != NULL);
 306         g_return_if_fail (GST_IS_DPMAN (dpman));
 307         g_return_if_fail (dparam_name != NULL);
 308
 309         dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
 310
 311         g_return_if_fail(dpwrap);
 312
 313         gst_dparam_detach(dpwrap->dparam);
 314         dpwrap->dparam = NULL;
 315
 316 }
 317
 318 /**
 319  * gst_dpman_get_dparam:
 320  * @dpman: GstDParamManager instance
 321  * @name: the name of an existing dparam instance
 322  *
 323  * Returns: the dparam with the given name - or NULL otherwise
 324  */
 325 GstDParam *
 326 gst_dpman_get_dparam (GstDParamManager *dpman, gchar *name)
 327 {
 328         GstDParamWrapper* dpwrap;
 329
 330         g_return_val_if_fail (dpman != NULL, NULL);
 331         g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
 332         g_return_val_if_fail (name != NULL, NULL);
 333
 334         dpwrap = g_hash_table_lookup(GST_DPMAN_DPARAMS(dpman), name);
 335         g_return_val_if_fail (dpwrap != NULL, NULL);
 336
 337         return dpwrap->dparam;
 338 }
 339
 340 /**
 341  * gst_dpman_get_dparam_type:
 342  * @dpman: GstDParamManager instance
 343  * @name: the name of dparam
 344  *
 345  * Returns: the type that this dparam requires/uses
 346  */
 347 GType
 348 gst_dpman_get_dparam_type (GstDParamManager *dpman, gchar *name)
 349 {
 350         GstDParamWrapper* dpwrap;
 351
 352         g_return_val_if_fail (dpman != NULL, 0);
 353         g_return_val_if_fail (GST_IS_DPMAN (dpman), 0);
 354         g_return_val_if_fail (name != NULL, 0);
 355
 356         dpwrap = g_hash_table_lookup(GST_DPMAN_DPARAMS(dpman), name);
 357         g_return_val_if_fail (dpwrap != NULL, 0);
 358
 359         return G_VALUE_TYPE(dpwrap->value);
 360 }
 361
 362 /*GstDParamSpec**
 363 gst_dpman_list_dparam_specs(GstDParamManager *dpman)
 364 {
 365         GstDParamWrapper* dpwrap;
 366         GSList *dpwraps;
 367         GParamSpec** param_specs;
 368         guint x = 0;
 369
 370         g_return_val_if_fail (dpman != NULL, NULL);
 371         g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
 372
 373         dpwraps = GST_DPMAN_DPARAMS_LIST(dpman);
 374
 375         param_specs = g_new0(GParamSpec*, g_slist_length(dpwraps) + 1);
 376
 377         while (dpwraps){
 378                 dpwrap = (GstDParamWrapper*)dpwraps->data;
 379                 param_specs[x++] = dpwrap->param_spec;
 380                 dpwraps = g_slist_next(dpwraps);
 381         }
 382         return param_specs;
 383 }
 384 */
 385
 386 GParamSpec*
 387 gst_dpman_get_param_spec (GstDParamManager *dpman, gchar *dparam_name)
 388 {
 389         GstDParamWrapper* dpwrap;
 390
 391         g_return_val_if_fail (dpman != NULL, NULL);
 392         g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
 393         g_return_val_if_fail (dparam_name != NULL, NULL);
 394
 395         dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
 396         return dpwrap->param_spec;
 397 }
 398
 399 /**
 400  * gst_dpman_register_mode
 401  * @klass: GstDParamManagerClass class instance
 402  * @modename: the unique name of the new mode
 403  * @preprocessfunc: the function which will be called before each buffer is processed
 404  * @processfunc: the function which may be called throughout the processing of a buffer
 405  * @setupfunc: the function which initialises the mode when activated
 406  * @teardownfunc: the function which frees any resources the mode uses
 407  *
 408  */
 409 void
 410 gst_dpman_register_mode (GstDParamManagerClass *klass,
 411                          gchar *modename,
 412                          GstDPMModePreProcessFunction preprocessfunc,
 413                          GstDPMModeProcessFunction processfunc,
 414                          GstDPMModeSetupFunction setupfunc,
 415                          GstDPMModeTeardownFunction teardownfunc)
 416 {
 417         GstDPMMode *mode;
 418
 419         g_return_if_fail (klass != NULL);
 420         g_return_if_fail (modename != NULL);
 421         g_return_if_fail (GST_IS_DPMAN_CLASS (klass));
 422
 423         mode = g_new0(GstDPMMode,1);
 424
 425         mode->preprocessfunc = preprocessfunc;
 426         mode->processfunc = processfunc;
 427         mode->setupfunc = setupfunc;
 428         mode->teardownfunc = teardownfunc;
 429
 430         g_hash_table_insert(klass->modes, modename, mode);
 431         GST_DEBUG(GST_CAT_PARAMS, "mode '%s' registered", modename);
 432 }
 433
 434 /**
 435  * gst_dpman_set_mode
 436  * @dpman: GstDParamManager instance
 437  * @modename: the name of the mode to use
 438  *
 439  * Returns: TRUE if the mode was set, FALSE otherwise
 440  */
 441 gboolean
 442 gst_dpman_set_mode(GstDParamManager *dpman, gchar *modename)
 443 {
 444         GstDPMMode *mode=NULL;
 445         GstDParamManagerClass *oclass;
 446
 447         g_return_val_if_fail (dpman != NULL, FALSE);
 448         g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
 449         g_return_val_if_fail (modename != NULL, FALSE);
 450
 451         oclass = (GstDParamManagerClass*)(G_OBJECT_GET_CLASS(dpman));
 452
 453         mode = g_hash_table_lookup(oclass->modes, modename);
 454         g_return_val_if_fail (mode != NULL, FALSE);
 455
 456         if (GST_DPMAN_MODE(dpman) == mode) {
 457                 GST_DEBUG(GST_CAT_PARAMS, "mode %s already set", modename);
 458                 return TRUE;
 459         }
 460
 461         GST_DEBUG(GST_CAT_PARAMS, "setting mode to %s", modename);
 462         if (GST_DPMAN_MODE(dpman) && GST_DPMAN_TEARDOWNFUNC(dpman)){
 463                 GST_DPMAN_TEARDOWNFUNC(dpman)(dpman);
 464         }
 465
 466         GST_DPMAN_MODE(dpman) = mode;
 467
 468         if (GST_DPMAN_SETUPFUNC(dpman)){
 469                 GST_DPMAN_SETUPFUNC(dpman)(dpman);
 470         }
 471
 472         return TRUE;
 473 }
 474
 475 /**
 476  * gst_dpman_set_parent
 477  * @dpman: GstDParamManager instance
 478  * @parent: the element that this GstDParamManager belongs to
 479  *
 480  */
 481 void
 482 gst_dpman_set_parent (GstDParamManager *dpman, GstElement *parent)
 483 {
 484         g_return_if_fail (dpman != NULL);
 485         g_return_if_fail (GST_IS_DPMAN (dpman));
 486         g_return_if_fail (parent != NULL);
 487         g_return_if_fail (GST_IS_ELEMENT (parent));
 488
 489         g_hash_table_insert(_element_registry, parent, dpman);
 490         gst_object_set_parent (GST_OBJECT (dpman), GST_OBJECT(parent));
 491         g_signal_connect(G_OBJECT(parent), "state_change",
 492                          G_CALLBACK (gst_dpman_state_change), dpman);
 493 }
 494
 495 /**
 496  * gst_dpman_get_manager
 497  * @parent: the element that the desired GstDParamManager belongs to
 498  *
 499  * Returns: the GstDParamManager which belongs to this element or NULL
 500  * if it doesn't exist
 501  */
 502 GstDParamManager *
 503 gst_dpman_get_manager (GstElement *parent)
 504 {
 505         GstDParamManager *dpman;
 506         g_return_val_if_fail (parent != NULL, NULL);
 507         g_return_val_if_fail (GST_IS_ELEMENT (parent), NULL);
 508
 509         dpman = (GstDParamManager*)g_hash_table_lookup(_element_registry, parent);
 510         return dpman;
 511 }
 512
 513 /**
 514  * gst_dpman_set_rate_change_pad
 515  * @dpman: GstDParamManager instance
 516  * @pad: the pad which may have a "rate" caps property
 517  *
 518  */
 519 void
 520 gst_dpman_set_rate_change_pad(GstDParamManager *dpman, GstPad *pad)
 521 {
 522         g_return_if_fail (dpman != NULL);
 523         g_return_if_fail (GST_IS_DPMAN (dpman));
 524         g_return_if_fail (pad != NULL);
 525         g_return_if_fail (GST_IS_PAD (pad));
 526
 527         g_signal_connect(G_OBJECT(pad), "caps_changed",
 528                          G_CALLBACK (gst_dpman_caps_changed), dpman);
 529 }
 530
 531 static GstDParamWrapper*
 532 gst_dpman_get_wrapper(GstDParamManager *dpman, gchar *dparam_name)
 533 {
 534         g_return_val_if_fail (dpman != NULL, NULL);
 535         g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
 536         g_return_val_if_fail (dparam_name != NULL, NULL);
 537
 538         return g_hash_table_lookup(GST_DPMAN_DPARAMS(dpman), dparam_name);
 539 }
 540
 541 static GstDParamWrapper*
 542 gst_dpman_new_wrapper(GstDParamManager *dpman,
 543                       GParamSpec *param_spec,
 544                       gboolean is_log,
 545                       gboolean is_rate,
 546                       GstDPMUpdateMethod update_method)
 547 {
 548         GstDParamWrapper* dpwrap;
 549         gchar *dparam_name;
 550
 551         g_return_val_if_fail (dpman != NULL, NULL);
 552         g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
 553         g_return_val_if_fail (param_spec != NULL, NULL);
 554
 555         dparam_name = g_strdup(g_param_spec_get_name(param_spec));
 556         g_return_val_if_fail(gst_dpman_get_wrapper(dpman, dparam_name) == NULL, NULL);
 557
 558         dpwrap = g_new0(GstDParamWrapper,1);
 559         dpwrap->update_method = update_method;
 560         dpwrap->value = g_new0(GValue,1);
 561         g_value_init(dpwrap->value, G_PARAM_SPEC_VALUE_TYPE(param_spec));
 562         dpwrap->param_spec = param_spec;
 563         dpwrap->is_log = is_log;
 564         dpwrap->is_rate = is_rate;
 565
 566         g_hash_table_insert(GST_DPMAN_DPARAMS(dpman), dparam_name, dpwrap);
 567         GST_DPMAN_DPARAMS_LIST(dpman) = g_slist_append(GST_DPMAN_DPARAMS_LIST(dpman), dpwrap);
 568
 569         return dpwrap;
 570 }
 571
 572
 573 static void
 574 gst_dpman_state_change (GstElement *element, gint old_state, gint new_state, GstDParamManager *dpman)
 575 {
 576         GSList *dwraps;
 577         GstDParam *dparam;
 578         GstDParamWrapper *dpwrap;
 579
 580         g_return_if_fail (dpman != NULL);
 581         g_return_if_fail (GST_IS_DPMAN (dpman));
 582
 583         if (new_state == GST_STATE_PLAYING){
 584                 GST_DEBUG(GST_CAT_PARAMS, "initialising params");
 585
 586                 /* force all params to be updated */
 587                 dwraps = GST_DPMAN_DPARAMS_LIST(dpman);
 588                 while (dwraps){
 589                         dpwrap = (GstDParamWrapper*)dwraps->data;
 590                         dparam = dpwrap->dparam;
 591
 592                         if (dparam){
 593                                 GST_DPARAM_READY_FOR_UPDATE(dparam) = TRUE;
 594                                 /*if (dparam->spec){
 595                                         g_value_copy(dparam->spec->default_val, dpwrap->value);
 596                                 }*/
 597                         }
 598                         dwraps = g_slist_next(dwraps);
 599                 }
 600         }
 601 }
 602
 603 static void
 604 gst_dpman_caps_changed (GstPad *pad, GstCaps *caps, GstDParamManager *dpman)
 605 {
 606         gint rate;
 607
 608         g_return_if_fail (caps != NULL);
 609         g_return_if_fail (dpman != NULL);
 610         g_return_if_fail (GST_IS_DPMAN (dpman));
 611
 612         gst_caps_get_int (caps, "rate", &rate);
 613         GST_DPMAN_RATE(dpman) = rate;
 614
 615         GST_DEBUG(GST_CAT_PARAMS, "got caps change %d", GST_DPMAN_RATE(dpman));
 616 }
 617
 618 static guint
 619 gst_dpman_preprocess_synchronous(GstDParamManager *dpman, guint frames, gint64 timestamp)
 620 {
 621         GSList *dwraps;
 622         GstDParam *dparam;
 623         GstDParamWrapper *dpwrap;
 624
 625         g_return_val_if_fail (dpman != NULL, frames);
 626         g_return_val_if_fail (GST_IS_DPMAN (dpman), frames);
 627
 628         /* now check whether any passive dparams are ready for an update */
 629         dwraps = GST_DPMAN_DPARAMS_LIST(dpman);
 630         while (dwraps){
 631                 dpwrap = (GstDParamWrapper*)dwraps->data;
 632                 dparam = dpwrap->dparam;
 633
 634                 if (dparam && (GST_DPARAM_READY_FOR_UPDATE(dparam) &&
 635                               (GST_DPARAM_NEXT_UPDATE_TIMESTAMP(dparam) <= timestamp))){
 636
 637                         switch (dpwrap->update_method) {
 638
 639                                 /* direct method - set the value directly in the struct of the element */
 640                                 case GST_DPMAN_DIRECT:
 641                                         GST_DPARAM_DO_UPDATE(dparam, timestamp, dpwrap->value);
 642                                         GST_DEBUG(GST_CAT_PARAMS, "doing direct update");
 643                                         switch (G_VALUE_TYPE(dpwrap->value)){
 644                                                 case G_TYPE_INT:
 645                                                         *(gint*)dpwrap->update_data = g_value_get_int(dpwrap->value);
 646                                                         break;
 647                                                 case G_TYPE_INT64:
 648                                                         *(gint64*)dpwrap->update_data = g_value_get_int64(dpwrap->value);
 649                                                         break;
 650                                                 case G_TYPE_FLOAT:
 651                                                         *(gfloat*)dpwrap->update_data = g_value_get_float(dpwrap->value);
 652                                                         break;
 653                                                 default:
 654                                                         break;
 655                                         }
 656                                         break;
 657
 658                                 /* callback method - call the element's callback so it can do what it likes */
 659                                 case GST_DPMAN_CALLBACK:
 660                                         GST_DPARAM_DO_UPDATE(dparam, timestamp, dpwrap->value);
 661                                         GST_DEBUG(GST_CAT_PARAMS, "doing callback update");
 662                                         GST_DPMAN_DO_UPDATE(dpwrap);
 663                                         break;
 664
 665                                 /* array method - generate an array of the right size  */
 666                                 /* with each value being the same (in synchronous update mode) */
 667                                 case GST_DPMAN_ARRAY:
 668                                         GST_DEBUG(GST_CAT_PARAMS, "doing array update");
 669                                         switch (G_VALUE_TYPE(dpwrap->value)){
 670                                                 case G_TYPE_INT:
 671                                                         break;
 672                                                 case G_TYPE_INT64:
 673                                                         break;
 674                                                 case G_TYPE_FLOAT:
 675                                                         break;
 676                                                 default:
 677                                                         break;
 678                                         }
 679                                         break;
 680                                 default:
 681                                         break;
 682                         }
 683                 }
 684                 dwraps = g_slist_next(dwraps);
 685         }
 686         return frames;
 687 }
 688
 689 static guint
 690 gst_dpman_preprocess_noop(GstDParamManager *dpman, guint frames, gint64 timestamp)
 691 {
 692         return frames;
 693 }
 694
 695 static guint
 696 gst_dpman_process_noop(GstDParamManager *dpman, guint frame_count)
 697 {
 698         return 0;
 699 }
 700