2001-12-23 17:27:58 +00:00
|
|
|
/* GStreamer
|
|
|
|
* Copyright (C) 2001 Steve Baker <stevebaker_org@yahoo.co.uk>
|
|
|
|
*
|
|
|
|
* gstdparammanager.c: Dynamic Parameter group functionality
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Library General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
|
|
|
* License along with this library; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <gst/control/dparammanager.h>
|
|
|
|
#include <gst/gstelement.h>
|
|
|
|
#include <gst/gstinfo.h>
|
|
|
|
|
|
|
|
static GHashTable *_element_registry;
|
2002-04-02 09:03:21 +00:00
|
|
|
enum {
|
|
|
|
NEW_REQUIRED_DPARAM,
|
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
static void gst_dpman_class_init (GstDParamManagerClass *klass);
|
|
|
|
static void gst_dpman_init (GstDParamManager *dpman);
|
|
|
|
static void gst_dpman_dispose (GObject *object);
|
2002-03-04 18:54:20 +00:00
|
|
|
static GstDParamWrapper* gst_dpman_new_wrapper(GstDParamManager *dpman, GParamSpec *param_spec, gboolean is_log, gboolean is_rate, GstDPMUpdateMethod update_method);
|
|
|
|
static GstDParamWrapper* gst_dpman_get_wrapper(GstDParamManager *dpman, gchar *dparam_name);
|
2002-02-21 20:44:59 +00:00
|
|
|
static void gst_dpman_state_change (GstElement *element, gint old_state, gint new_state, GstDParamManager *dpman);
|
2001-12-23 17:27:58 +00:00
|
|
|
static void gst_dpman_caps_changed (GstPad *pad, GstCaps *caps, GstDParamManager *dpman);
|
|
|
|
static guint gst_dpman_preprocess_synchronous(GstDParamManager *dpman, guint frames, gint64 timestamp);
|
|
|
|
static guint gst_dpman_preprocess_noop(GstDParamManager *dpman, guint frames, gint64 timestamp);
|
|
|
|
static guint gst_dpman_process_noop(GstDParamManager *dpman, guint frame_count);
|
|
|
|
|
|
|
|
static GObjectClass *parent_class;
|
2002-04-02 09:03:21 +00:00
|
|
|
static guint gst_dpman_signals[LAST_SIGNAL] = { 0 };
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
_gst_dpman_initialize()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
GType
|
|
|
|
gst_dpman_get_type (void)
|
|
|
|
{
|
|
|
|
static GType dpman_type = 0;
|
|
|
|
|
|
|
|
if (!dpman_type) {
|
|
|
|
static const GTypeInfo dpman_info = {
|
|
|
|
sizeof(GstDParamManagerClass),
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc)gst_dpman_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
sizeof(GstDParamManager),
|
|
|
|
0,
|
|
|
|
(GInstanceInitFunc)gst_dpman_init,
|
|
|
|
};
|
|
|
|
dpman_type = g_type_register_static(GST_TYPE_OBJECT, "GstDParamManager", &dpman_info, 0);
|
|
|
|
}
|
|
|
|
return dpman_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_dpman_class_init (GstDParamManagerClass *klass)
|
|
|
|
{
|
|
|
|
GstObjectClass *gstobject_class;
|
|
|
|
GObjectClass *gobject_class;
|
|
|
|
|
|
|
|
parent_class = g_type_class_peek_parent (klass);
|
|
|
|
|
|
|
|
gstobject_class = (GstObjectClass*) klass;
|
|
|
|
gobject_class = (GObjectClass*) klass;
|
|
|
|
gobject_class->dispose = gst_dpman_dispose;
|
|
|
|
|
|
|
|
klass->modes = g_hash_table_new(g_str_hash,g_str_equal);
|
|
|
|
|
|
|
|
gst_dpman_register_mode (klass, "synchronous",
|
|
|
|
gst_dpman_preprocess_synchronous, gst_dpman_process_noop, NULL, NULL);
|
|
|
|
gst_dpman_register_mode (klass, "asynchronous",
|
|
|
|
gst_dpman_preprocess_noop, gst_dpman_process_noop, NULL, NULL);
|
|
|
|
gst_dpman_register_mode (klass, "disabled",
|
|
|
|
gst_dpman_preprocess_noop, gst_dpman_process_noop, NULL, NULL);
|
|
|
|
|
|
|
|
_element_registry = g_hash_table_new(NULL,NULL);
|
2002-04-02 09:03:21 +00:00
|
|
|
|
|
|
|
gst_dpman_signals[NEW_REQUIRED_DPARAM] =
|
|
|
|
g_signal_new ("new_required_dparam", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (GstDParamManagerClass, new_required_dparam), NULL, NULL,
|
|
|
|
gst_marshal_VOID__STRING, G_TYPE_NONE, 1,
|
|
|
|
G_TYPE_STRING);
|
|
|
|
|
2001-12-23 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_dpman_init (GstDParamManager *dpman)
|
|
|
|
{
|
|
|
|
GST_DPMAN_DPARAMS(dpman) = g_hash_table_new(g_str_hash,g_str_equal);
|
|
|
|
GST_DPMAN_DPARAMS_LIST(dpman) = NULL;
|
|
|
|
GST_DPMAN_NAME(dpman) = NULL;
|
|
|
|
GST_DPMAN_PARENT(dpman) = NULL;
|
|
|
|
GST_DPMAN_MODE_NAME(dpman) = NULL;
|
|
|
|
GST_DPMAN_MODE(dpman) = NULL;
|
|
|
|
GST_DPMAN_MODE_DATA(dpman) = NULL;
|
|
|
|
GST_DPMAN_RATE(dpman) = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_new:
|
|
|
|
* @name: name of the GstDParamManager instance
|
|
|
|
* @parent: element which created this instance
|
|
|
|
*
|
|
|
|
* Returns: a new instance of GstDParamManager
|
|
|
|
*/
|
|
|
|
GstDParamManager*
|
|
|
|
gst_dpman_new (gchar *name, GstElement *parent)
|
|
|
|
{
|
|
|
|
GstDParamManager *dpman;
|
|
|
|
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
|
|
|
|
dpman = g_object_new (gst_dpman_get_type (), NULL);
|
|
|
|
gst_object_set_name (GST_OBJECT (dpman), name);
|
|
|
|
gst_dpman_set_parent(dpman, parent);
|
|
|
|
|
|
|
|
gst_dpman_set_mode(dpman, "disabled");
|
|
|
|
|
|
|
|
return dpman;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_dpman_dispose (GObject *object)
|
|
|
|
{
|
|
|
|
/* GstDParamManager *dpman = GST_DPMAN(object); */
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (parent_class)->dispose (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_add_required_dparam_callback:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @update_func: callback to update the element with the new value
|
|
|
|
* @update_data: will be included in the call to update_func
|
|
|
|
*
|
|
|
|
* Returns: true if it was successfully added
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_dpman_add_required_dparam_callback (GstDParamManager *dpman,
|
2002-03-04 18:54:20 +00:00
|
|
|
GParamSpec *param_spec,
|
|
|
|
gboolean is_log,
|
|
|
|
gboolean is_rate,
|
2001-12-23 17:27:58 +00:00
|
|
|
GstDPMUpdateFunction update_func,
|
|
|
|
gpointer update_data)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
|
|
|
|
g_return_val_if_fail (update_func != NULL, FALSE);
|
|
|
|
|
2002-03-04 18:54:20 +00:00
|
|
|
dpwrap = gst_dpman_new_wrapper(dpman, param_spec, is_log, is_rate, GST_DPMAN_CALLBACK);
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (dpwrap != NULL, FALSE);
|
|
|
|
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS,"adding required callback dparam '%s'", g_param_spec_get_name(param_spec));
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
dpwrap->update_func = update_func;
|
|
|
|
dpwrap->update_data = update_data;
|
2002-04-02 09:03:21 +00:00
|
|
|
|
|
|
|
g_signal_emit (G_OBJECT (dpman), gst_dpman_signals[NEW_REQUIRED_DPARAM], 0, g_param_spec_get_name(param_spec));
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_add_required_dparam_direct:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @update_data: pointer to the member to be updated
|
|
|
|
*
|
|
|
|
* Returns: true if it was successfully added
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_dpman_add_required_dparam_direct (GstDParamManager *dpman,
|
2002-03-04 18:54:20 +00:00
|
|
|
GParamSpec *param_spec,
|
|
|
|
gboolean is_log,
|
|
|
|
gboolean is_rate,
|
|
|
|
gpointer update_data)
|
2001-12-23 17:27:58 +00:00
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
|
|
|
|
g_return_val_if_fail (update_data != NULL, FALSE);
|
|
|
|
|
2002-03-04 18:54:20 +00:00
|
|
|
dpwrap = gst_dpman_new_wrapper(dpman, param_spec, is_log, is_rate, GST_DPMAN_DIRECT);
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (dpwrap != NULL, FALSE);
|
|
|
|
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS,"adding required direct dparam '%s'", g_param_spec_get_name(param_spec));
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
dpwrap->update_data = update_data;
|
|
|
|
|
2002-04-02 09:03:21 +00:00
|
|
|
g_signal_emit (G_OBJECT (dpman), gst_dpman_signals[NEW_REQUIRED_DPARAM], 0, g_param_spec_get_name(param_spec));
|
|
|
|
|
2001-12-23 17:27:58 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_add_required_dparam_array:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @dparam_name: a parameter name unique to this GstDParamManager
|
|
|
|
* @update_data: pointer to where the array will be stored
|
|
|
|
*
|
|
|
|
* Returns: true if it was successfully added
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_dpman_add_required_dparam_array (GstDParamManager *dpman,
|
2002-03-04 18:54:20 +00:00
|
|
|
GParamSpec *param_spec,
|
|
|
|
gboolean is_log,
|
|
|
|
gboolean is_rate,
|
|
|
|
gpointer update_data)
|
2001-12-23 17:27:58 +00:00
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
|
|
|
|
g_return_val_if_fail (update_data != NULL, FALSE);
|
|
|
|
|
2002-03-04 18:54:20 +00:00
|
|
|
dpwrap = gst_dpman_new_wrapper(dpman, param_spec, is_log, is_rate, GST_DPMAN_ARRAY);
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (dpwrap != NULL, FALSE);
|
|
|
|
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS,"adding required array dparam '%s'", g_param_spec_get_name(param_spec));
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
dpwrap->update_data = update_data;
|
|
|
|
|
2002-04-02 09:03:21 +00:00
|
|
|
g_signal_emit (G_OBJECT (dpman), gst_dpman_signals[NEW_REQUIRED_DPARAM], 0, g_param_spec_get_name(param_spec));
|
|
|
|
|
2001-12-23 17:27:58 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_remove_required_dparam:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @dparam_name: the name of an existing parameter
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_dpman_remove_required_dparam (GstDParamManager *dpman, gchar *dparam_name)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_if_fail (dpman != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN (dpman));
|
|
|
|
g_return_if_fail (dparam_name != NULL);
|
|
|
|
|
|
|
|
dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
|
|
|
|
|
|
|
|
g_return_if_fail(dpwrap != NULL);
|
|
|
|
g_return_if_fail(dpwrap->dparam == NULL);
|
|
|
|
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "removing required dparam: %s", dparam_name);
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
g_hash_table_remove(GST_DPMAN_DPARAMS(dpman), dparam_name);
|
|
|
|
GST_DPMAN_DPARAMS_LIST(dpman) = g_slist_remove(GST_DPMAN_DPARAMS_LIST(dpman), dpwrap);
|
|
|
|
|
|
|
|
g_free(dpwrap->value);
|
|
|
|
g_free(dpwrap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_attach_dparam:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @dparam_name: a name previously added with gst_dpman_add_required_dparam
|
|
|
|
* @dparam: GstDParam instance to attach
|
|
|
|
*
|
|
|
|
* Returns: true if it was successfully attached
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_dpman_attach_dparam (GstDParamManager *dpman, gchar *dparam_name, GstDParam *dparam)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
|
|
|
|
g_return_val_if_fail (dparam_name != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (dparam != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_DPARAM (dparam), FALSE);
|
|
|
|
g_return_val_if_fail (dparam != NULL, FALSE);
|
|
|
|
|
|
|
|
dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
|
|
|
|
|
|
|
|
g_return_val_if_fail(dpwrap != NULL, FALSE);
|
|
|
|
g_return_val_if_fail(dpwrap->value != NULL, FALSE);
|
|
|
|
|
|
|
|
dpwrap->dparam = dparam;
|
2002-03-04 18:54:20 +00:00
|
|
|
gst_dparam_attach(dparam, dpman, dpwrap->param_spec, dpwrap->is_log, dpwrap->is_rate);
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_detach_dparam:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @dparam_name: the name of a parameter with a previously attached GstDParam
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_dpman_detach_dparam (GstDParamManager *dpman, gchar *dparam_name)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_if_fail (dpman != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN (dpman));
|
|
|
|
g_return_if_fail (dparam_name != NULL);
|
|
|
|
|
|
|
|
dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
|
|
|
|
|
|
|
|
g_return_if_fail(dpwrap);
|
|
|
|
|
|
|
|
gst_dparam_detach(dpwrap->dparam);
|
|
|
|
dpwrap->dparam = NULL;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_get_dparam:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @name: the name of an existing dparam instance
|
|
|
|
*
|
|
|
|
* Returns: the dparam with the given name - or NULL otherwise
|
|
|
|
*/
|
|
|
|
GstDParam *
|
|
|
|
gst_dpman_get_dparam (GstDParamManager *dpman, gchar *name)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
|
|
|
|
dpwrap = g_hash_table_lookup(GST_DPMAN_DPARAMS(dpman), name);
|
|
|
|
g_return_val_if_fail (dpwrap != NULL, NULL);
|
|
|
|
|
|
|
|
return dpwrap->dparam;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_get_dparam_type:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @name: the name of dparam
|
|
|
|
*
|
|
|
|
* Returns: the type that this dparam requires/uses
|
|
|
|
*/
|
|
|
|
GType
|
|
|
|
gst_dpman_get_dparam_type (GstDParamManager *dpman, gchar *name)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, 0);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), 0);
|
|
|
|
g_return_val_if_fail (name != NULL, 0);
|
|
|
|
|
|
|
|
dpwrap = g_hash_table_lookup(GST_DPMAN_DPARAMS(dpman), name);
|
|
|
|
g_return_val_if_fail (dpwrap != NULL, 0);
|
|
|
|
|
|
|
|
return G_VALUE_TYPE(dpwrap->value);
|
|
|
|
}
|
|
|
|
|
2002-04-02 09:03:21 +00:00
|
|
|
GParamSpec**
|
2001-12-23 17:27:58 +00:00
|
|
|
gst_dpman_list_dparam_specs(GstDParamManager *dpman)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
GSList *dpwraps;
|
2002-03-04 18:54:20 +00:00
|
|
|
GParamSpec** param_specs;
|
2001-12-23 17:27:58 +00:00
|
|
|
guint x = 0;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
|
|
|
|
|
|
|
|
dpwraps = GST_DPMAN_DPARAMS_LIST(dpman);
|
|
|
|
|
2002-03-04 18:54:20 +00:00
|
|
|
param_specs = g_new0(GParamSpec*, g_slist_length(dpwraps) + 1);
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
while (dpwraps){
|
|
|
|
dpwrap = (GstDParamWrapper*)dpwraps->data;
|
2002-03-04 18:54:20 +00:00
|
|
|
param_specs[x++] = dpwrap->param_spec;
|
2001-12-23 17:27:58 +00:00
|
|
|
dpwraps = g_slist_next(dpwraps);
|
|
|
|
}
|
2002-03-04 18:54:20 +00:00
|
|
|
return param_specs;
|
2001-12-23 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
2002-03-04 18:54:20 +00:00
|
|
|
GParamSpec*
|
|
|
|
gst_dpman_get_param_spec (GstDParamManager *dpman, gchar *dparam_name)
|
2001-12-23 17:27:58 +00:00
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
|
|
|
|
g_return_val_if_fail (dparam_name != NULL, NULL);
|
|
|
|
|
|
|
|
dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
|
2002-03-04 18:54:20 +00:00
|
|
|
return dpwrap->param_spec;
|
2001-12-23 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_register_mode
|
|
|
|
* @klass: GstDParamManagerClass class instance
|
|
|
|
* @modename: the unique name of the new mode
|
|
|
|
* @preprocessfunc: the function which will be called before each buffer is processed
|
|
|
|
* @processfunc: the function which may be called throughout the processing of a buffer
|
|
|
|
* @setupfunc: the function which initialises the mode when activated
|
|
|
|
* @teardownfunc: the function which frees any resources the mode uses
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_dpman_register_mode (GstDParamManagerClass *klass,
|
|
|
|
gchar *modename,
|
|
|
|
GstDPMModePreProcessFunction preprocessfunc,
|
|
|
|
GstDPMModeProcessFunction processfunc,
|
|
|
|
GstDPMModeSetupFunction setupfunc,
|
|
|
|
GstDPMModeTeardownFunction teardownfunc)
|
|
|
|
{
|
|
|
|
GstDPMMode *mode;
|
|
|
|
|
|
|
|
g_return_if_fail (klass != NULL);
|
|
|
|
g_return_if_fail (modename != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN_CLASS (klass));
|
|
|
|
|
|
|
|
mode = g_new0(GstDPMMode,1);
|
|
|
|
|
|
|
|
mode->preprocessfunc = preprocessfunc;
|
|
|
|
mode->processfunc = processfunc;
|
|
|
|
mode->setupfunc = setupfunc;
|
|
|
|
mode->teardownfunc = teardownfunc;
|
|
|
|
|
|
|
|
g_hash_table_insert(klass->modes, modename, mode);
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "mode '%s' registered", modename);
|
2001-12-23 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_set_mode
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @modename: the name of the mode to use
|
|
|
|
*
|
|
|
|
* Returns: TRUE if the mode was set, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_dpman_set_mode(GstDParamManager *dpman, gchar *modename)
|
|
|
|
{
|
|
|
|
GstDPMMode *mode=NULL;
|
|
|
|
GstDParamManagerClass *oclass;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), FALSE);
|
|
|
|
g_return_val_if_fail (modename != NULL, FALSE);
|
|
|
|
|
|
|
|
oclass = (GstDParamManagerClass*)(G_OBJECT_GET_CLASS(dpman));
|
|
|
|
|
|
|
|
mode = g_hash_table_lookup(oclass->modes, modename);
|
|
|
|
g_return_val_if_fail (mode != NULL, FALSE);
|
|
|
|
|
|
|
|
if (GST_DPMAN_MODE(dpman) == mode) {
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "mode %s already set", modename);
|
2001-12-23 17:27:58 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "setting mode to %s", modename);
|
2001-12-23 17:27:58 +00:00
|
|
|
if (GST_DPMAN_MODE(dpman) && GST_DPMAN_TEARDOWNFUNC(dpman)){
|
|
|
|
GST_DPMAN_TEARDOWNFUNC(dpman)(dpman);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_DPMAN_MODE(dpman) = mode;
|
|
|
|
|
|
|
|
if (GST_DPMAN_SETUPFUNC(dpman)){
|
|
|
|
GST_DPMAN_SETUPFUNC(dpman)(dpman);
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_set_parent
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @parent: the element that this GstDParamManager belongs to
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_dpman_set_parent (GstDParamManager *dpman, GstElement *parent)
|
|
|
|
{
|
|
|
|
g_return_if_fail (dpman != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN (dpman));
|
|
|
|
g_return_if_fail (parent != NULL);
|
|
|
|
g_return_if_fail (GST_IS_ELEMENT (parent));
|
|
|
|
|
|
|
|
g_hash_table_insert(_element_registry, parent, dpman);
|
|
|
|
gst_object_set_parent (GST_OBJECT (dpman), GST_OBJECT(parent));
|
|
|
|
g_signal_connect(G_OBJECT(parent), "state_change",
|
|
|
|
G_CALLBACK (gst_dpman_state_change), dpman);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_get_manager
|
|
|
|
* @parent: the element that the desired GstDParamManager belongs to
|
|
|
|
*
|
|
|
|
* Returns: the GstDParamManager which belongs to this element or NULL
|
|
|
|
* if it doesn't exist
|
|
|
|
*/
|
|
|
|
GstDParamManager *
|
|
|
|
gst_dpman_get_manager (GstElement *parent)
|
|
|
|
{
|
|
|
|
GstDParamManager *dpman;
|
|
|
|
g_return_val_if_fail (parent != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (parent), NULL);
|
|
|
|
|
|
|
|
dpman = (GstDParamManager*)g_hash_table_lookup(_element_registry, parent);
|
|
|
|
return dpman;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_dpman_set_rate_change_pad
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @pad: the pad which may have a "rate" caps property
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_dpman_set_rate_change_pad(GstDParamManager *dpman, GstPad *pad)
|
|
|
|
{
|
|
|
|
g_return_if_fail (dpman != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN (dpman));
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
|
|
|
|
|
|
|
g_signal_connect(G_OBJECT(pad), "caps_changed",
|
|
|
|
G_CALLBACK (gst_dpman_caps_changed), dpman);
|
|
|
|
}
|
|
|
|
|
2002-04-02 09:03:21 +00:00
|
|
|
/**
|
|
|
|
* gst_dpman_bypass_dparam:
|
|
|
|
* @dpman: GstDParamManager instance
|
|
|
|
* @dparam_name: the name of dparam
|
|
|
|
*
|
|
|
|
* If a dparam is attached to this dparam_name, it will be detached
|
|
|
|
* and a warning will be issued. This should be called in the _set_property
|
|
|
|
* function of an element if the value it changes is also changed by a dparam.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_dpman_bypass_dparam(GstDParamManager *dpman, gchar *dparam_name)
|
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
|
|
|
|
|
|
|
g_return_if_fail (dpman != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN (dpman));
|
|
|
|
g_return_if_fail (dparam_name != NULL);
|
|
|
|
|
|
|
|
dpwrap = gst_dpman_get_wrapper(dpman, dparam_name);
|
|
|
|
g_return_if_fail (dpwrap != NULL);
|
|
|
|
|
|
|
|
if (dpwrap->dparam != NULL){
|
|
|
|
g_warning("Bypassing attached dparam '%s'. It will be detached", dparam_name);
|
|
|
|
gst_dpman_detach_dparam(dpman, dparam_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-23 17:27:58 +00:00
|
|
|
static GstDParamWrapper*
|
|
|
|
gst_dpman_get_wrapper(GstDParamManager *dpman, gchar *dparam_name)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (dpman != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
|
|
|
|
g_return_val_if_fail (dparam_name != NULL, NULL);
|
|
|
|
|
|
|
|
return g_hash_table_lookup(GST_DPMAN_DPARAMS(dpman), dparam_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static GstDParamWrapper*
|
2002-03-04 18:54:20 +00:00
|
|
|
gst_dpman_new_wrapper(GstDParamManager *dpman,
|
|
|
|
GParamSpec *param_spec,
|
|
|
|
gboolean is_log,
|
|
|
|
gboolean is_rate,
|
|
|
|
GstDPMUpdateMethod update_method)
|
2001-12-23 17:27:58 +00:00
|
|
|
{
|
|
|
|
GstDParamWrapper* dpwrap;
|
2002-03-04 18:54:20 +00:00
|
|
|
gchar *dparam_name;
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), NULL);
|
2002-03-04 18:54:20 +00:00
|
|
|
g_return_val_if_fail (param_spec != NULL, NULL);
|
2001-12-23 17:27:58 +00:00
|
|
|
|
2002-03-04 18:54:20 +00:00
|
|
|
dparam_name = g_strdup(g_param_spec_get_name(param_spec));
|
2001-12-23 17:27:58 +00:00
|
|
|
g_return_val_if_fail(gst_dpman_get_wrapper(dpman, dparam_name) == NULL, NULL);
|
|
|
|
|
|
|
|
dpwrap = g_new0(GstDParamWrapper,1);
|
|
|
|
dpwrap->update_method = update_method;
|
|
|
|
dpwrap->value = g_new0(GValue,1);
|
2002-03-04 18:54:20 +00:00
|
|
|
g_value_init(dpwrap->value, G_PARAM_SPEC_VALUE_TYPE(param_spec));
|
|
|
|
dpwrap->param_spec = param_spec;
|
|
|
|
dpwrap->is_log = is_log;
|
|
|
|
dpwrap->is_rate = is_rate;
|
2001-12-23 17:27:58 +00:00
|
|
|
|
|
|
|
g_hash_table_insert(GST_DPMAN_DPARAMS(dpman), dparam_name, dpwrap);
|
|
|
|
GST_DPMAN_DPARAMS_LIST(dpman) = g_slist_append(GST_DPMAN_DPARAMS_LIST(dpman), dpwrap);
|
|
|
|
|
|
|
|
return dpwrap;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2002-02-21 20:44:59 +00:00
|
|
|
gst_dpman_state_change (GstElement *element, gint old_state, gint new_state, GstDParamManager *dpman)
|
2001-12-23 17:27:58 +00:00
|
|
|
{
|
|
|
|
GSList *dwraps;
|
|
|
|
GstDParam *dparam;
|
|
|
|
GstDParamWrapper *dpwrap;
|
|
|
|
|
|
|
|
g_return_if_fail (dpman != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN (dpman));
|
|
|
|
|
2002-02-21 20:44:59 +00:00
|
|
|
if (new_state == GST_STATE_PLAYING){
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "initialising params");
|
2001-12-23 17:27:58 +00:00
|
|
|
|
2002-03-19 04:10:13 +00:00
|
|
|
/* force all params to be updated */
|
2001-12-23 17:27:58 +00:00
|
|
|
dwraps = GST_DPMAN_DPARAMS_LIST(dpman);
|
|
|
|
while (dwraps){
|
|
|
|
dpwrap = (GstDParamWrapper*)dwraps->data;
|
|
|
|
dparam = dpwrap->dparam;
|
|
|
|
|
|
|
|
if (dparam){
|
|
|
|
GST_DPARAM_READY_FOR_UPDATE(dparam) = TRUE;
|
2002-03-04 18:54:20 +00:00
|
|
|
/*if (dparam->spec){
|
|
|
|
g_value_copy(dparam->spec->default_val, dpwrap->value);
|
|
|
|
}*/
|
2001-12-23 17:27:58 +00:00
|
|
|
}
|
|
|
|
dwraps = g_slist_next(dwraps);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_dpman_caps_changed (GstPad *pad, GstCaps *caps, GstDParamManager *dpman)
|
|
|
|
{
|
2002-03-30 17:08:02 +00:00
|
|
|
gint rate;
|
|
|
|
|
2001-12-23 17:27:58 +00:00
|
|
|
g_return_if_fail (caps != NULL);
|
|
|
|
g_return_if_fail (dpman != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DPMAN (dpman));
|
|
|
|
|
2002-03-30 17:08:02 +00:00
|
|
|
gst_caps_get_int (caps, "rate", &rate);
|
|
|
|
GST_DPMAN_RATE(dpman) = rate;
|
2001-12-23 17:27:58 +00:00
|
|
|
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "got caps change %d", GST_DPMAN_RATE(dpman));
|
2001-12-23 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static guint
|
|
|
|
gst_dpman_preprocess_synchronous(GstDParamManager *dpman, guint frames, gint64 timestamp)
|
|
|
|
{
|
|
|
|
GSList *dwraps;
|
|
|
|
GstDParam *dparam;
|
|
|
|
GstDParamWrapper *dpwrap;
|
|
|
|
|
|
|
|
g_return_val_if_fail (dpman != NULL, frames);
|
|
|
|
g_return_val_if_fail (GST_IS_DPMAN (dpman), frames);
|
|
|
|
|
2002-03-19 04:10:13 +00:00
|
|
|
/* now check whether any passive dparams are ready for an update */
|
2001-12-23 17:27:58 +00:00
|
|
|
dwraps = GST_DPMAN_DPARAMS_LIST(dpman);
|
|
|
|
while (dwraps){
|
|
|
|
dpwrap = (GstDParamWrapper*)dwraps->data;
|
|
|
|
dparam = dpwrap->dparam;
|
|
|
|
|
|
|
|
if (dparam && (GST_DPARAM_READY_FOR_UPDATE(dparam) &&
|
|
|
|
(GST_DPARAM_NEXT_UPDATE_TIMESTAMP(dparam) <= timestamp))){
|
|
|
|
|
|
|
|
switch (dpwrap->update_method) {
|
|
|
|
|
2002-03-19 04:10:13 +00:00
|
|
|
/* direct method - set the value directly in the struct of the element */
|
2001-12-23 17:27:58 +00:00
|
|
|
case GST_DPMAN_DIRECT:
|
2002-03-04 18:54:20 +00:00
|
|
|
GST_DPARAM_DO_UPDATE(dparam, timestamp, dpwrap->value);
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "doing direct update");
|
2001-12-23 17:27:58 +00:00
|
|
|
switch (G_VALUE_TYPE(dpwrap->value)){
|
|
|
|
case G_TYPE_INT:
|
|
|
|
*(gint*)dpwrap->update_data = g_value_get_int(dpwrap->value);
|
|
|
|
break;
|
2002-03-04 18:54:20 +00:00
|
|
|
case G_TYPE_INT64:
|
|
|
|
*(gint64*)dpwrap->update_data = g_value_get_int64(dpwrap->value);
|
2001-12-23 17:27:58 +00:00
|
|
|
break;
|
|
|
|
case G_TYPE_FLOAT:
|
|
|
|
*(gfloat*)dpwrap->update_data = g_value_get_float(dpwrap->value);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2002-03-19 04:10:13 +00:00
|
|
|
/* callback method - call the element's callback so it can do what it likes */
|
2001-12-23 17:27:58 +00:00
|
|
|
case GST_DPMAN_CALLBACK:
|
2002-03-04 18:54:20 +00:00
|
|
|
GST_DPARAM_DO_UPDATE(dparam, timestamp, dpwrap->value);
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "doing callback update");
|
2001-12-23 17:27:58 +00:00
|
|
|
GST_DPMAN_DO_UPDATE(dpwrap);
|
|
|
|
break;
|
|
|
|
|
2002-03-19 04:10:13 +00:00
|
|
|
/* array method - generate an array of the right size */
|
|
|
|
/* with each value being the same (in synchronous update mode) */
|
2001-12-23 17:27:58 +00:00
|
|
|
case GST_DPMAN_ARRAY:
|
2002-03-24 22:07:09 +00:00
|
|
|
GST_DEBUG(GST_CAT_PARAMS, "doing array update");
|
2001-12-23 17:27:58 +00:00
|
|
|
switch (G_VALUE_TYPE(dpwrap->value)){
|
|
|
|
case G_TYPE_INT:
|
|
|
|
break;
|
2002-03-04 18:54:20 +00:00
|
|
|
case G_TYPE_INT64:
|
2001-12-23 17:27:58 +00:00
|
|
|
break;
|
|
|
|
case G_TYPE_FLOAT:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dwraps = g_slist_next(dwraps);
|
|
|
|
}
|
|
|
|
return frames;
|
|
|
|
}
|
|
|
|
|
|
|
|
static guint
|
|
|
|
gst_dpman_preprocess_noop(GstDParamManager *dpman, guint frames, gint64 timestamp)
|
|
|
|
{
|
|
|
|
return frames;
|
|
|
|
}
|
|
|
|
|
|
|
|
static guint
|
|
|
|
gst_dpman_process_noop(GstDParamManager *dpman, guint frame_count)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|