/**
* gst_controller_get:
* @self: the controller object which handles the properties
* @property_name: the name of the property to get
* @timestamp: the time the control-change should be read from
*
* Gets the value for the given controller-handled property at the requested
* time.
*
* Returns: the GValue of the property at the given time, or %NULL if the
* property isn't handled by the controller
*/
GValue *
gst_controller_get (GstController * self, gchar * property_name,
GstClockTime timestamp)
{
GstControlledProperty *prop;
GValue *val = NULL;
g_return_val_if_fail (GST_IS_CONTROLLER (self), NULL);
g_return_val_if_fail (property_name, NULL);
g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (timestamp), NULL);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
val = g_new0 (GValue, 1);
g_value_init (val, G_PARAM_SPEC_VALUE_TYPE (prop->pspec));
if (prop->csource) {
gboolean res;
/* get current value via control source */
res = gst_control_source_get_value (prop->csource, timestamp, val);
if (!res) {
g_free (val);
val = NULL;
}
} else {
g_object_get_property (self->object, prop->name, val);
}
}
g_mutex_unlock (self->lock);
return val;
}
/**
* gst_controller_get_value_array:
* @self: the controller that handles the values
* @timestamp: the time that should be processed
* @value_array: array to put control-values in
*
* Function to be able to get an array of values for one element property.
*
* All fields of @value_array must be filled correctly. Especially the
* @value_array->values array must be big enough to keep the requested amount
* of values.
*
* The type of the values in the array is the same as the property's type.
*
* <note><para>This doesn't modify the controlled GObject property!</para></note>
*
* Returns: %TRUE if the given array could be filled, %FALSE otherwise
*/
gboolean
gst_controller_get_value_array (GstController * self, GstClockTime timestamp,
GstValueArray * value_array)
{
gboolean res = FALSE;
GstControlledProperty *prop;
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (timestamp), FALSE);
g_return_val_if_fail (value_array, FALSE);
g_return_val_if_fail (value_array->property_name, FALSE);
g_return_val_if_fail (value_array->values, FALSE);
g_mutex_lock (self->lock);
if ((prop =
gst_controller_find_controlled_property (self,
value_array->property_name))) {
/* get current value_array via control source */
if (!prop->csource)
goto out;
res =
gst_control_source_get_value_array (prop->csource, timestamp,
value_array);
}
out:
g_mutex_unlock (self->lock);
return res;
}
/**
* gst_controller_set_control_source:
* @self: the controller object
* @property_name: name of the property for which the #GstControlSource should be set
* @csource: the #GstControlSource that should be used for the property
*
* Sets the #GstControlSource for @property_name. If there already was a #GstControlSource
* for this property it will be unreferenced.
*
* Returns: %FALSE if the given property isn't handled by the controller or the new #GstControlSource
* couldn't be bound to the property, %TRUE if everything worked as expected.
*
* Since: 0.10.14
*/
gboolean
gst_controller_set_control_source (GstController * self, gchar * property_name,
GstControlSource * csource)
{
GstControlledProperty *prop;
gboolean ret = FALSE;
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
GstControlSource *old = prop->csource;
if (csource && (ret = gst_control_source_bind (csource, prop->pspec))) {
g_object_ref (csource);
prop->csource = csource;
} else if (!csource) {
ret = TRUE;
prop->csource = NULL;
}
if (ret && old)
g_object_unref (old);
}
g_mutex_unlock (self->lock);
return ret;
}
/**
* gst_controller_remove_properties_list:
* @self: the controller object from which some properties should be removed
* @list: #GList of property names that should be removed
*
* Removes the given object properties from the controller
*
* Returns: %FALSE if one of the given property isn't handled by the controller, %TRUE otherwise
*/
gboolean
gst_controller_remove_properties_list (GstController * self, GList * list)
{
gboolean res = TRUE;
GstControlledProperty *prop;
gchar *name;
GList *tmp;
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
for (tmp = list; tmp; tmp = g_list_next (tmp)) {
name = (gchar *) tmp->data;
/* find the property in the properties list of the controller, remove and free it */
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, name))) {
self->properties = g_list_remove (self->properties, prop);
//g_signal_handler_disconnect (self->object, prop->notify_handler_id);
gst_controlled_property_free (prop);
} else {
res = FALSE;
}
g_mutex_unlock (self->lock);
}
return res;
}
gboolean
gst_controller_unset (GstController * self, gchar * property_name,
GstClockTime timestamp)
{
gboolean res = FALSE;
GstControlledProperty *prop;
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
g_return_val_if_fail (property_name, FALSE);
g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (timestamp), FALSE);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
if (!prop->csource || !GST_IS_INTERPOLATION_CONTROL_SOURCE (prop->csource))
goto out;
res =
gst_interpolation_control_source_unset (GST_INTERPOLATION_CONTROL_SOURCE
(prop->csource), timestamp);
}
out:
g_mutex_unlock (self->lock);
return res;
}
gboolean
gst_controller_set_from_list (GstController * self, gchar * property_name,
GSList * timedvalues)
{
gboolean res = FALSE;
GstControlledProperty *prop;
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
g_return_val_if_fail (property_name, FALSE);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
/* FIXME: backward compat, add GstInterpolationControlSource */
if (!prop->csource)
gst_controlled_property_add_interpolation_control_source (prop);
if (!GST_IS_INTERPOLATION_CONTROL_SOURCE (prop->csource))
goto out;
res =
gst_interpolation_control_source_set_from_list
(GST_INTERPOLATION_CONTROL_SOURCE (prop->csource), timedvalues);
}
out:
g_mutex_unlock (self->lock);
return res;
}
EXPORT_C
#endif
gboolean
gst_controller_remove_properties_valist (GstController * self, va_list var_args)
{
gboolean res = TRUE;
GstControlledProperty *prop;
gchar *name;
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
while ((name = va_arg (var_args, gchar *))) {
/* find the property in the properties list of the controller, remove and free it */
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, name))) {
self->properties = g_list_remove (self->properties, prop);
//g_signal_handler_disconnect (self->object, prop->notify_handler_id);
gst_controlled_property_free (prop);
} else {
res = FALSE;
}
g_mutex_unlock (self->lock);
}
return res;
}
EXPORT_C
#endif
const GList *
gst_controller_get_all (GstController * self, gchar * property_name)
{
const GList *res = NULL;
GstControlledProperty *prop;
g_return_val_if_fail (GST_IS_CONTROLLER (self), NULL);
g_return_val_if_fail (property_name, NULL);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
if (!prop->csource || !GST_IS_INTERPOLATION_CONTROL_SOURCE (prop->csource))
goto out;
res =
gst_interpolation_control_source_get_all
(GST_INTERPOLATION_CONTROL_SOURCE (prop->csource));
}
out:
g_mutex_unlock (self->lock);
return res;
}
void
gst_controller_set_property_disabled (GstController * self,
gchar * property_name, gboolean disabled)
{
GstControlledProperty *prop;
g_return_if_fail (GST_IS_CONTROLLER (self));
g_return_if_fail (property_name);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
prop->disabled = disabled;
}
g_mutex_unlock (self->lock);
}
gboolean
gst_controller_set_interpolation_mode (GstController * self,
gchar * property_name, GstInterpolateMode mode)
{
gboolean res = FALSE;
GstControlledProperty *prop;
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
g_return_val_if_fail (property_name, FALSE);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
res = gst_controlled_property_set_interpolation_mode (prop, mode);
}
g_mutex_unlock (self->lock);
return res;
}
/**
* gst_controller_get_control_source:
* @self: the controller object
* @property_name: name of the property for which the #GstControlSource should be get
*
* Gets the corresponding #GstControlSource for the property. This should be unreferenced
* again after use.
*
* Returns: the #GstControlSource for @property_name or NULL if the property is not
* controlled by this controller or no #GstControlSource was assigned yet.
*
* Since: 0.10.14
*/
GstControlSource *
gst_controller_get_control_source (GstController * self, gchar * property_name)
{
GstControlledProperty *prop;
GstControlSource *ret = NULL;
g_return_val_if_fail (GST_IS_CONTROLLER (self), NULL);
g_return_val_if_fail (property_name, NULL);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
ret = prop->csource;
}
g_mutex_unlock (self->lock);
if (ret)
g_object_ref (ret);
return ret;
}
gboolean
gst_controller_unset_all (GstController * self, gchar * property_name)
{
GstControlledProperty *prop;
g_return_val_if_fail (GST_IS_CONTROLLER (self), FALSE);
g_return_val_if_fail (property_name, FALSE);
g_mutex_lock (self->lock);
if ((prop = gst_controller_find_controlled_property (self, property_name))) {
if (!prop->csource || !GST_IS_INTERPOLATION_CONTROL_SOURCE (prop->csource))
goto out;
gst_interpolation_control_source_unset_all (GST_INTERPOLATION_CONTROL_SOURCE
(prop->csource));
}
out:
g_mutex_unlock (self->lock);
return TRUE;
}
/*
* gst_controller_add_property:
* @self: the controller object or %NULL if none yet exists
* @object: object to bind the property
* @name: name of projecty in @object
* @ref_existing: pointer to flag that tracks if we need to ref an existng
* controller still
*
* Creates a new #GstControlledProperty if there is none for property @name yet.
* In case this is the first controlled propery, it creates the controller as
* well.
*
* Returns: a newly created controller object or reffed existing one with the
* given property bound.
*/
static GstController *
gst_controller_add_property (GstController * self, GObject * object,
gchar * name, gboolean * ref_existing)
{
/* test if this property isn't yet controlled */
if (!self || !gst_controller_find_controlled_property (self, name)) {
GstControlledProperty *prop;
/* create GstControlledProperty and add to self->propeties List */
if ((prop = gst_controlled_property_new (object, name))) {
/* if we don't have a controller object yet, now is the time to create one */
if (!self) {
self = g_object_newv (GST_TYPE_CONTROLLER, 0, NULL);
self->object = g_object_ref (object);
/* store the controller */
g_object_set_qdata (object, priv_gst_controller_key, self);
*ref_existing = FALSE;
} else {
/* only want one single _ref(), even for multiple properties */
if (*ref_existing) {
g_object_ref (self);
*ref_existing = FALSE;
GST_INFO ("returning existing controller");
}
}
self->properties = g_list_prepend (self->properties, prop);
}
} else {
GST_WARNING ("trying to control property %s again", name);
if (*ref_existing) {
g_object_ref (self);
*ref_existing = FALSE;
}
}
return self;
}