mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-11 19:06:33 +00:00
91b5a5804a
Only allow elements that were created by ges_clip_create_track_elements (or copied from such an element) to be added to a clip. This prevents users from adding arbitrary elements to a clip. As an exception, a user can add GESBaseEffects to clips whose class supports it, i.e. to a GESSourceClip and a GESBaseEffectClip. This change also introduces a distinction between the core elements of a clip (created by ges_clip_create_track_elements) and non-core elements (currently, only GESBaseEffects, for some classes). In particular, GESBaseEffectClip will now distinguish between its core elements and effects added by the user. This means that the core elements will always have the lowest priority, and will not be listed as top effects. This is desirable because it brings the behaviour of GESBaseEffectClip in line with other clip types.
1584 lines
48 KiB
C
1584 lines
48 KiB
C
/* GStreamer Editing Services
|
|
* Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
|
|
* 2009 Nokia Corporation
|
|
*
|
|
* 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., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
/**
|
|
* SECTION:gestrackelement
|
|
* @title: GESTrackElement
|
|
* @short_description: Base Class for the elements of a #GESTrack
|
|
*
|
|
* A #GESTrackElement is a #GESTimelineElement that specifically belongs
|
|
* to a single #GESTrack of its #GESTimelineElement:timeline. Its
|
|
* #GESTimelineElement:start and #GESTimelineElement:duration specify its
|
|
* temporal extent in the track. Specifically, a track element wraps some
|
|
* nleobject, such as an #nlesource or #nleoperation, which can be
|
|
* retrieved with ges_track_element_get_nleobject(), and its
|
|
* #GESTimelineElement:start, #GESTimelineElement:duration,
|
|
* #GESTimelineElement:in-point, #GESTimelineElement:priority and
|
|
* #GESTrackElement:active properties expose the corresponding nleobject
|
|
* properties. When a track element is added to a track, its nleobject is
|
|
* added to the corresponding #nlecomposition that the track wraps.
|
|
*
|
|
* Most users will not have to work directly with track elements since a
|
|
* #GESClip will automatically create track elements for its timeline's
|
|
* tracks and take responsibility for updating them. The only track
|
|
* elements that are not automatically created by clips, but a user is
|
|
* likely to want to create, are #GESEffect-s.
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "ges-internal.h"
|
|
#include "ges-extractable.h"
|
|
#include "ges-track-element.h"
|
|
#include "ges-clip.h"
|
|
#include "ges-meta-container.h"
|
|
|
|
struct _GESTrackElementPrivate
|
|
{
|
|
GESTrackType track_type;
|
|
|
|
GstElement *nleobject; /* The NleObject */
|
|
GstElement *element; /* The element contained in the nleobject (can be NULL) */
|
|
|
|
GESTrack *track;
|
|
|
|
gboolean locked; /* If TRUE, then moves in sync with its controlling
|
|
* GESClip */
|
|
|
|
GHashTable *bindings_hashtable; /* We need this if we want to be able to serialize
|
|
and deserialize keyframes */
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_ACTIVE,
|
|
PROP_TRACK_TYPE,
|
|
PROP_TRACK,
|
|
PROP_LAST
|
|
};
|
|
|
|
static GParamSpec *properties[PROP_LAST];
|
|
|
|
enum
|
|
{
|
|
CONTROL_BINDING_ADDED,
|
|
CONTROL_BINDING_REMOVED,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
static guint ges_track_element_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GESTrackElement, ges_track_element,
|
|
GES_TYPE_TIMELINE_ELEMENT);
|
|
|
|
static GstElement *ges_track_element_create_gnl_object_func (GESTrackElement *
|
|
object);
|
|
|
|
static gboolean _set_start (GESTimelineElement * element, GstClockTime start);
|
|
static gboolean _set_inpoint (GESTimelineElement * element,
|
|
GstClockTime inpoint);
|
|
static gboolean _set_duration (GESTimelineElement * element,
|
|
GstClockTime duration);
|
|
static gboolean _set_priority (GESTimelineElement * element, guint32 priority);
|
|
GESTrackType _get_track_types (GESTimelineElement * object);
|
|
|
|
static void
|
|
_update_control_bindings (GESTimelineElement * element, GstClockTime inpoint,
|
|
GstClockTime duration);
|
|
|
|
static gboolean
|
|
_lookup_child (GESTrackElement * object,
|
|
const gchar * prop_name, GstElement ** element, GParamSpec ** pspec)
|
|
{
|
|
return
|
|
GES_TIMELINE_ELEMENT_GET_CLASS (object)->lookup_child
|
|
(GES_TIMELINE_ELEMENT (object), prop_name, (GObject **) element, pspec);
|
|
}
|
|
|
|
static gboolean
|
|
strv_find_str (const gchar ** strv, const char *str)
|
|
{
|
|
guint i;
|
|
|
|
if (strv == NULL)
|
|
return FALSE;
|
|
|
|
for (i = 0; strv[i]; i++) {
|
|
if (g_strcmp0 (strv[i], str) == 0)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static guint32
|
|
_get_layer_priority (GESTimelineElement * element)
|
|
{
|
|
if (!element->parent)
|
|
return GES_TIMELINE_ELEMENT_NO_LAYER_PRIORITY;
|
|
|
|
return ges_timeline_element_get_layer_priority (element->parent);
|
|
}
|
|
|
|
static void
|
|
ges_track_element_get_property (GObject * object, guint property_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GESTrackElement *track_element = GES_TRACK_ELEMENT (object);
|
|
|
|
switch (property_id) {
|
|
case PROP_ACTIVE:
|
|
g_value_set_boolean (value, ges_track_element_is_active (track_element));
|
|
break;
|
|
case PROP_TRACK_TYPE:
|
|
g_value_set_flags (value, track_element->priv->track_type);
|
|
break;
|
|
case PROP_TRACK:
|
|
g_value_set_object (value, track_element->priv->track);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ges_track_element_set_property (GObject * object, guint property_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GESTrackElement *track_element = GES_TRACK_ELEMENT (object);
|
|
|
|
switch (property_id) {
|
|
case PROP_ACTIVE:
|
|
ges_track_element_set_active (track_element, g_value_get_boolean (value));
|
|
break;
|
|
case PROP_TRACK_TYPE:
|
|
track_element->priv->track_type = g_value_get_flags (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ges_track_element_dispose (GObject * object)
|
|
{
|
|
GESTrackElement *element = GES_TRACK_ELEMENT (object);
|
|
GESTrackElementPrivate *priv = element->priv;
|
|
|
|
if (priv->bindings_hashtable)
|
|
g_hash_table_destroy (priv->bindings_hashtable);
|
|
|
|
if (priv->nleobject) {
|
|
GstState cstate;
|
|
|
|
if (priv->track != NULL) {
|
|
g_error ("%p Still in %p, this means that you forgot"
|
|
" to remove it from the GESTrack it is contained in. You always need"
|
|
" to remove a GESTrackElement from its track before dropping the last"
|
|
" reference\n"
|
|
"This problem may also be caused by a refcounting bug in"
|
|
" the application or GES itself.", object, priv->track);
|
|
gst_element_get_state (priv->nleobject, &cstate, NULL, 0);
|
|
if (cstate != GST_STATE_NULL)
|
|
gst_element_set_state (priv->nleobject, GST_STATE_NULL);
|
|
}
|
|
|
|
g_object_set_qdata (G_OBJECT (priv->nleobject),
|
|
NLE_OBJECT_TRACK_ELEMENT_QUARK, NULL);
|
|
gst_object_unref (priv->nleobject);
|
|
priv->nleobject = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (ges_track_element_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
ges_track_element_constructed (GObject * gobject)
|
|
{
|
|
GESTrackElementClass *class;
|
|
GstElement *nleobject;
|
|
gdouble media_duration_factor;
|
|
gchar *tmp;
|
|
GESTrackElement *object = GES_TRACK_ELEMENT (gobject);
|
|
|
|
GST_DEBUG_OBJECT (object, "Creating NleObject");
|
|
|
|
class = GES_TRACK_ELEMENT_GET_CLASS (object);
|
|
g_assert (class->create_gnl_object);
|
|
|
|
nleobject = class->create_gnl_object (object);
|
|
if (G_UNLIKELY (nleobject == NULL)) {
|
|
GST_ERROR_OBJECT (object, "Could not create NleObject");
|
|
|
|
return;
|
|
}
|
|
|
|
tmp = g_strdup_printf ("%s:%s", G_OBJECT_TYPE_NAME (object),
|
|
GST_OBJECT_NAME (nleobject));
|
|
gst_object_set_name (GST_OBJECT (nleobject), tmp);
|
|
g_free (tmp);
|
|
|
|
GST_DEBUG_OBJECT (object, "Got a valid NleObject, now filling it in");
|
|
|
|
object->priv->nleobject = gst_object_ref (nleobject);
|
|
g_object_set_qdata (G_OBJECT (nleobject), NLE_OBJECT_TRACK_ELEMENT_QUARK,
|
|
object);
|
|
|
|
/* Set some properties on the NleObject */
|
|
g_object_set (object->priv->nleobject,
|
|
"start", GES_TIMELINE_ELEMENT_START (object),
|
|
"inpoint", GES_TIMELINE_ELEMENT_INPOINT (object),
|
|
"duration", GES_TIMELINE_ELEMENT_DURATION (object),
|
|
"priority", GES_TIMELINE_ELEMENT_PRIORITY (object),
|
|
"active", object->active, NULL);
|
|
|
|
media_duration_factor =
|
|
ges_timeline_element_get_media_duration_factor (GES_TIMELINE_ELEMENT
|
|
(object));
|
|
g_object_set (object->priv->nleobject,
|
|
"media-duration-factor", media_duration_factor, NULL);
|
|
|
|
G_OBJECT_CLASS (ges_track_element_parent_class)->constructed (gobject);
|
|
}
|
|
|
|
static void
|
|
ges_track_element_class_init (GESTrackElementClass * klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GESTimelineElementClass *element_class = GES_TIMELINE_ELEMENT_CLASS (klass);
|
|
|
|
object_class->get_property = ges_track_element_get_property;
|
|
object_class->set_property = ges_track_element_set_property;
|
|
object_class->dispose = ges_track_element_dispose;
|
|
object_class->constructed = ges_track_element_constructed;
|
|
|
|
|
|
/**
|
|
* GESTrackElement:active:
|
|
*
|
|
* Whether the effect of the element should be applied in its
|
|
* #GESTrackElement:track. If set to %FALSE, it will not be used in
|
|
* the output of the track.
|
|
*/
|
|
properties[PROP_ACTIVE] =
|
|
g_param_spec_boolean ("active", "Active", "Use object in output", TRUE,
|
|
G_PARAM_READWRITE);
|
|
g_object_class_install_property (object_class, PROP_ACTIVE,
|
|
properties[PROP_ACTIVE]);
|
|
|
|
/**
|
|
* GESTrackElement:track-type:
|
|
*
|
|
* The track type of the element, which determines the type of track the
|
|
* element can be added to (see #GESTrack:track-type). This should
|
|
* correspond to the type of data that the element can produce or
|
|
* process.
|
|
*/
|
|
properties[PROP_TRACK_TYPE] = g_param_spec_flags ("track-type", "Track Type",
|
|
"The track type of the object", GES_TYPE_TRACK_TYPE,
|
|
GES_TRACK_TYPE_UNKNOWN, G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
|
|
g_object_class_install_property (object_class, PROP_TRACK_TYPE,
|
|
properties[PROP_TRACK_TYPE]);
|
|
|
|
/**
|
|
* GESTrackElement:track:
|
|
*
|
|
* The track that this element belongs to, or %NULL if it does not
|
|
* belong to a track.
|
|
*/
|
|
properties[PROP_TRACK] = g_param_spec_object ("track", "Track",
|
|
"The track the object is in", GES_TYPE_TRACK, G_PARAM_READABLE);
|
|
g_object_class_install_property (object_class, PROP_TRACK,
|
|
properties[PROP_TRACK]);
|
|
|
|
/**
|
|
* GESTrackElement::control-binding-added:
|
|
* @track_element: A #GESTrackElement
|
|
* @control_binding: The control binding that has been added
|
|
*
|
|
* This is emitted when a control binding is added to a child property
|
|
* of the track element.
|
|
*/
|
|
ges_track_element_signals[CONTROL_BINDING_ADDED] =
|
|
g_signal_new ("control-binding-added", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, GST_TYPE_CONTROL_BINDING);
|
|
|
|
/**
|
|
* GESTrackElement::control-binding-removed:
|
|
* @track_element: A #GESTrackElement
|
|
* @control_binding: The control binding that has been removed
|
|
*
|
|
* This is emitted when a control binding is removed from a child
|
|
* property of the track element.
|
|
*/
|
|
ges_track_element_signals[CONTROL_BINDING_REMOVED] =
|
|
g_signal_new ("control-binding-removed", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, GST_TYPE_CONTROL_BINDING);
|
|
|
|
element_class->set_start = _set_start;
|
|
element_class->set_duration = _set_duration;
|
|
element_class->set_inpoint = _set_inpoint;
|
|
element_class->set_priority = _set_priority;
|
|
element_class->get_track_types = _get_track_types;
|
|
element_class->deep_copy = ges_track_element_copy_properties;
|
|
element_class->get_layer_priority = _get_layer_priority;
|
|
|
|
klass->create_gnl_object = ges_track_element_create_gnl_object_func;
|
|
klass->lookup_child = _lookup_child;
|
|
}
|
|
|
|
static void
|
|
ges_track_element_init (GESTrackElement * self)
|
|
{
|
|
GESTrackElementPrivate *priv = self->priv =
|
|
ges_track_element_get_instance_private (self);
|
|
|
|
/* Sane default values */
|
|
GES_TIMELINE_ELEMENT_START (self) = 0;
|
|
GES_TIMELINE_ELEMENT_INPOINT (self) = 0;
|
|
GES_TIMELINE_ELEMENT_DURATION (self) = GST_SECOND;
|
|
GES_TIMELINE_ELEMENT_PRIORITY (self) = 0;
|
|
self->active = TRUE;
|
|
|
|
priv->bindings_hashtable = g_hash_table_new_full (g_str_hash, g_str_equal,
|
|
g_free, NULL);
|
|
}
|
|
|
|
static gfloat
|
|
interpolate_values_for_position (GstTimedValue * first_value,
|
|
GstTimedValue * second_value, guint64 position, gboolean absolute)
|
|
{
|
|
gfloat diff;
|
|
GstClockTime interval;
|
|
gfloat value_at_pos;
|
|
|
|
g_assert (second_value || first_value);
|
|
|
|
if (first_value == NULL)
|
|
return second_value->value;
|
|
|
|
if (second_value == NULL)
|
|
return first_value->value;
|
|
|
|
diff = second_value->value - first_value->value;
|
|
interval = second_value->timestamp - first_value->timestamp;
|
|
|
|
if (position > first_value->timestamp)
|
|
value_at_pos =
|
|
first_value->value + ((float) (position -
|
|
first_value->timestamp) / (float) interval) * diff;
|
|
else
|
|
value_at_pos =
|
|
first_value->value - ((float) (first_value->timestamp -
|
|
position) / (float) interval) * diff;
|
|
|
|
if (!absolute)
|
|
value_at_pos = CLAMP (value_at_pos, 0.0, 1.0);
|
|
|
|
return value_at_pos;
|
|
}
|
|
|
|
static void
|
|
_update_control_bindings (GESTimelineElement * element, GstClockTime inpoint,
|
|
GstClockTime duration)
|
|
{
|
|
GParamSpec **specs;
|
|
guint n, n_specs;
|
|
GstControlBinding *binding;
|
|
GstTimedValueControlSource *source;
|
|
GESTrackElement *self = GES_TRACK_ELEMENT (element);
|
|
|
|
specs = ges_track_element_list_children_properties (self, &n_specs);
|
|
|
|
for (n = 0; n < n_specs; ++n) {
|
|
GList *values, *tmp;
|
|
gboolean absolute;
|
|
GstTimedValue *last, *first, *prev = NULL, *next = NULL;
|
|
gfloat value_at_pos;
|
|
|
|
binding = ges_track_element_get_control_binding (self, specs[n]->name);
|
|
|
|
if (!binding)
|
|
continue;
|
|
|
|
g_object_get (binding, "control_source", &source, NULL);
|
|
|
|
g_object_get (binding, "absolute", &absolute, NULL);
|
|
if (duration == 0) {
|
|
gst_timed_value_control_source_unset_all (GST_TIMED_VALUE_CONTROL_SOURCE
|
|
(source));
|
|
continue;
|
|
}
|
|
|
|
values =
|
|
gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE
|
|
(source));
|
|
|
|
if (g_list_length (values) == 0)
|
|
continue;
|
|
|
|
first = values->data;
|
|
|
|
for (tmp = values->next; tmp; tmp = tmp->next) {
|
|
next = tmp->data;
|
|
|
|
if (next->timestamp > inpoint)
|
|
break;
|
|
}
|
|
g_list_free (values);
|
|
|
|
value_at_pos =
|
|
interpolate_values_for_position (first, next, inpoint, absolute);
|
|
gst_timed_value_control_source_unset (source, first->timestamp);
|
|
gst_timed_value_control_source_set (source, inpoint, value_at_pos);
|
|
|
|
values =
|
|
gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE
|
|
(source));
|
|
|
|
if (duration != GST_CLOCK_TIME_NONE) {
|
|
last = g_list_last (values)->data;
|
|
|
|
for (tmp = g_list_last (values)->prev; tmp; tmp = tmp->prev) {
|
|
prev = tmp->data;
|
|
|
|
if (prev->timestamp < duration + inpoint)
|
|
break;
|
|
}
|
|
g_list_free (values);
|
|
|
|
value_at_pos =
|
|
interpolate_values_for_position (prev, last, duration + inpoint,
|
|
absolute);
|
|
|
|
gst_timed_value_control_source_unset (source, last->timestamp);
|
|
gst_timed_value_control_source_set (source, duration + inpoint,
|
|
value_at_pos);
|
|
values =
|
|
gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE
|
|
(source));
|
|
}
|
|
|
|
for (tmp = values; tmp; tmp = tmp->next) {
|
|
GstTimedValue *value = tmp->data;
|
|
if (value->timestamp < inpoint)
|
|
gst_timed_value_control_source_unset (source, value->timestamp);
|
|
else if (duration != GST_CLOCK_TIME_NONE
|
|
&& value->timestamp > duration + inpoint)
|
|
gst_timed_value_control_source_unset (source, value->timestamp);
|
|
}
|
|
g_list_free (values);
|
|
}
|
|
|
|
g_free (specs);
|
|
}
|
|
|
|
static gboolean
|
|
_set_start (GESTimelineElement * element, GstClockTime start)
|
|
{
|
|
GESTrackElement *object = GES_TRACK_ELEMENT (element);
|
|
|
|
g_return_val_if_fail (object->priv->nleobject, FALSE);
|
|
|
|
if (G_UNLIKELY (start == _START (object)))
|
|
return -1;
|
|
|
|
g_object_set (object->priv->nleobject, "start", start, NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_set_inpoint (GESTimelineElement * element, GstClockTime inpoint)
|
|
{
|
|
GESTrackElement *object = GES_TRACK_ELEMENT (element);
|
|
|
|
g_return_val_if_fail (object->priv->nleobject, FALSE);
|
|
|
|
if (G_UNLIKELY (inpoint == _INPOINT (object)))
|
|
return -1;
|
|
|
|
g_object_set (object->priv->nleobject, "inpoint", inpoint, NULL);
|
|
_update_control_bindings (element, inpoint, GST_CLOCK_TIME_NONE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_set_duration (GESTimelineElement * element, GstClockTime duration)
|
|
{
|
|
GESTrackElement *object = GES_TRACK_ELEMENT (element);
|
|
GESTrackElementPrivate *priv = object->priv;
|
|
|
|
g_return_val_if_fail (object->priv->nleobject, FALSE);
|
|
|
|
if (GST_CLOCK_TIME_IS_VALID (_MAXDURATION (element)) &&
|
|
duration > _INPOINT (object) + _MAXDURATION (element))
|
|
duration = _MAXDURATION (element) - _INPOINT (object);
|
|
|
|
if (G_UNLIKELY (duration == _DURATION (object)))
|
|
return -1;
|
|
|
|
g_object_set (priv->nleobject, "duration", duration, NULL);
|
|
|
|
_update_control_bindings (element, ges_timeline_element_get_inpoint (element),
|
|
duration);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_set_priority (GESTimelineElement * element, guint32 priority)
|
|
{
|
|
GESTrackElement *object = GES_TRACK_ELEMENT (element);
|
|
|
|
g_return_val_if_fail (object->priv->nleobject, FALSE);
|
|
|
|
if (priority < MIN_NLE_PRIO) {
|
|
GST_INFO_OBJECT (element, "Priority (%d) < MIN_NLE_PRIO, setting it to %d",
|
|
priority, MIN_NLE_PRIO);
|
|
priority = MIN_NLE_PRIO;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (object, "priority:%" G_GUINT32_FORMAT, priority);
|
|
|
|
if (G_UNLIKELY (priority == _PRIORITY (object)))
|
|
return FALSE;
|
|
|
|
g_object_set (object->priv->nleobject, "priority", priority, NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GESTrackType
|
|
_get_track_types (GESTimelineElement * object)
|
|
{
|
|
return ges_track_element_get_track_type (GES_TRACK_ELEMENT (object));
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_set_active:
|
|
* @object: A #GESTrackElement
|
|
* @active: Whether @object should be active in its track
|
|
*
|
|
* Sets #GESTrackElement:active for the element.
|
|
*
|
|
* Returns: %TRUE if the property was *toggled*.
|
|
*/
|
|
gboolean
|
|
ges_track_element_set_active (GESTrackElement * object, gboolean active)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
|
|
g_return_val_if_fail (object->priv->nleobject, FALSE);
|
|
|
|
GST_DEBUG_OBJECT (object, "object:%p, active:%d", object, active);
|
|
|
|
if (G_UNLIKELY (active == object->active))
|
|
return FALSE;
|
|
|
|
g_object_set (object->priv->nleobject, "active", active, NULL);
|
|
|
|
/* FIXME: no need to check again at this point */
|
|
if (active != object->active) {
|
|
object->active = active;
|
|
if (GES_TRACK_ELEMENT_GET_CLASS (object)->active_changed)
|
|
GES_TRACK_ELEMENT_GET_CLASS (object)->active_changed (object, active);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_set_track_type:
|
|
* @object: A #GESTrackElement
|
|
* @type: The new track-type for @object
|
|
*
|
|
* Sets the #GESTrackElement:track-type for the element.
|
|
*/
|
|
void
|
|
ges_track_element_set_track_type (GESTrackElement * object, GESTrackType type)
|
|
{
|
|
g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
|
|
|
|
if (object->priv->track_type != type) {
|
|
object->priv->track_type = type;
|
|
g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_TRACK_TYPE]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_track_type:
|
|
* @object: A #GESTrackElement
|
|
*
|
|
* Gets the #GESTrackElement:track-type for the element.
|
|
*
|
|
* Returns: The track-type of @object.
|
|
*/
|
|
GESTrackType
|
|
ges_track_element_get_track_type (GESTrackElement * object)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), GES_TRACK_TYPE_UNKNOWN);
|
|
|
|
return object->priv->track_type;
|
|
}
|
|
|
|
/* default 'create_gnl_object' virtual method implementation */
|
|
static GstElement *
|
|
ges_track_element_create_gnl_object_func (GESTrackElement * self)
|
|
{
|
|
GESTrackElementClass *klass = NULL;
|
|
GstElement *child = NULL;
|
|
GstElement *nleobject;
|
|
|
|
klass = GES_TRACK_ELEMENT_GET_CLASS (self);
|
|
|
|
if (G_UNLIKELY (self->priv->nleobject != NULL))
|
|
goto already_have_nleobject;
|
|
|
|
if (G_UNLIKELY (klass->nleobject_factorytype == NULL))
|
|
goto no_nlefactory;
|
|
|
|
GST_DEBUG ("Creating a supporting nleobject of type '%s'",
|
|
klass->nleobject_factorytype);
|
|
|
|
nleobject = gst_element_factory_make (klass->nleobject_factorytype, NULL);
|
|
|
|
if (G_UNLIKELY (nleobject == NULL))
|
|
goto no_nleobject;
|
|
|
|
if (klass->create_element) {
|
|
GST_DEBUG ("Calling subclass 'create_element' vmethod");
|
|
child = klass->create_element (self);
|
|
|
|
if (G_UNLIKELY (!child))
|
|
goto child_failure;
|
|
|
|
if (!gst_bin_add (GST_BIN (nleobject), child))
|
|
goto add_failure;
|
|
|
|
GST_DEBUG ("Succesfully got the element to put in the nleobject");
|
|
self->priv->element = child;
|
|
}
|
|
|
|
GST_DEBUG ("done");
|
|
return nleobject;
|
|
|
|
|
|
/* ERROR CASES */
|
|
|
|
already_have_nleobject:
|
|
{
|
|
GST_ERROR ("Already controlling a NleObject %s",
|
|
GST_ELEMENT_NAME (self->priv->nleobject));
|
|
return NULL;
|
|
}
|
|
|
|
no_nlefactory:
|
|
{
|
|
GST_ERROR ("No GESTrackElement::nleobject_factorytype implementation!");
|
|
return NULL;
|
|
}
|
|
|
|
no_nleobject:
|
|
{
|
|
GST_ERROR ("Error creating a nleobject of type '%s'",
|
|
klass->nleobject_factorytype);
|
|
return NULL;
|
|
}
|
|
|
|
child_failure:
|
|
{
|
|
GST_ERROR ("create_element returned NULL");
|
|
gst_object_unref (nleobject);
|
|
return NULL;
|
|
}
|
|
|
|
add_failure:
|
|
{
|
|
GST_ERROR ("Error adding the contents to the nleobject");
|
|
gst_object_unref (child);
|
|
gst_object_unref (nleobject);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ges_track_element_add_child_props (GESTrackElement * self,
|
|
GstElement * child, const gchar ** wanted_categories,
|
|
const gchar ** blacklist, const gchar ** whitelist)
|
|
{
|
|
GstElementFactory *factory;
|
|
const gchar *klass;
|
|
GParamSpec **parray;
|
|
GObjectClass *gobject_klass;
|
|
gchar **categories;
|
|
guint i;
|
|
|
|
factory = gst_element_get_factory (child);
|
|
/* FIXME: handle NULL factory */
|
|
klass = gst_element_factory_get_metadata (factory,
|
|
GST_ELEMENT_METADATA_KLASS);
|
|
|
|
if (strv_find_str (blacklist, GST_OBJECT_NAME (factory))) {
|
|
GST_DEBUG_OBJECT (self, "%s blacklisted", GST_OBJECT_NAME (factory));
|
|
return;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (self, "Looking at element '%s' of klass '%s'",
|
|
GST_ELEMENT_NAME (child), klass);
|
|
|
|
categories = g_strsplit (klass, "/", 0);
|
|
|
|
for (i = 0; categories[i]; i++) {
|
|
if ((!wanted_categories ||
|
|
strv_find_str (wanted_categories, categories[i]))) {
|
|
guint i, nb_specs;
|
|
|
|
gobject_klass = G_OBJECT_GET_CLASS (child);
|
|
parray = g_object_class_list_properties (gobject_klass, &nb_specs);
|
|
for (i = 0; i < nb_specs; i++) {
|
|
if ((!whitelist && (parray[i]->flags & G_PARAM_WRITABLE))
|
|
|| (strv_find_str (whitelist, parray[i]->name))) {
|
|
ges_timeline_element_add_child_property (GES_TIMELINE_ELEMENT
|
|
(self), parray[i], G_OBJECT (child));
|
|
}
|
|
}
|
|
g_free (parray);
|
|
|
|
GST_DEBUG
|
|
("%d configurable properties of '%s' added to property hashtable",
|
|
nb_specs, GST_ELEMENT_NAME (child));
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_strfreev (categories);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_add_children_props:
|
|
* @self: A #GESTrackElement
|
|
* @element: The child object to retrieve properties from
|
|
* @wanted_categories: (array zero-terminated=1) (transfer none) (allow-none):
|
|
* An array of element factory "klass" categories to whitelist, or %NULL
|
|
* to accept all categories
|
|
* @blacklist: (array zero-terminated=1) (transfer none) (allow-none): A
|
|
* blacklist of element factory names, or %NULL to not blacklist any
|
|
* element factory
|
|
* @whitelist: (array zero-terminated=1) (transfer none) (allow-none): A
|
|
* whitelist of element property names, or %NULL to whitelist all
|
|
* writeable properties
|
|
*
|
|
* Adds all the properties of a #GstElement that match the criteria as
|
|
* children properties of the track element. If the name of @element's
|
|
* #GstElementFactory is not in @blacklist, and the factory's
|
|
* #GST_ELEMENT_METADATA_KLASS contains at least one member of
|
|
* @wanted_categories (e.g. #GST_ELEMENT_FACTORY_KLASS_DECODER), then
|
|
* all the properties of @element that are also in @whitelist are added as
|
|
* child properties of @self using
|
|
* ges_timeline_element_add_child_property().
|
|
*
|
|
* This is intended to be used by subclasses when constructing.
|
|
*/
|
|
void
|
|
ges_track_element_add_children_props (GESTrackElement * self,
|
|
GstElement * element, const gchar ** wanted_categories,
|
|
const gchar ** blacklist, const gchar ** whitelist)
|
|
{
|
|
GValue item = { 0, };
|
|
GstIterator *it;
|
|
gboolean done = FALSE;
|
|
|
|
if (!GST_IS_BIN (element)) {
|
|
ges_track_element_add_child_props (self, element, wanted_categories,
|
|
blacklist, whitelist);
|
|
return;
|
|
}
|
|
|
|
/* We go over child elements recursivly, and add writable properties to the
|
|
* hashtable */
|
|
it = gst_bin_iterate_recurse (GST_BIN (element));
|
|
while (!done) {
|
|
switch (gst_iterator_next (it, &item)) {
|
|
case GST_ITERATOR_OK:
|
|
{
|
|
GstElement *child = g_value_get_object (&item);
|
|
ges_track_element_add_child_props (self, child, wanted_categories,
|
|
blacklist, whitelist);
|
|
g_value_reset (&item);
|
|
break;
|
|
}
|
|
case GST_ITERATOR_RESYNC:
|
|
/* FIXME, properly restart the process */
|
|
GST_DEBUG ("iterator resync");
|
|
gst_iterator_resync (it);
|
|
break;
|
|
|
|
case GST_ITERATOR_DONE:
|
|
GST_DEBUG ("iterator done");
|
|
done = TRUE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
g_value_unset (&item);
|
|
}
|
|
gst_iterator_free (it);
|
|
}
|
|
|
|
/* INTERNAL USAGE */
|
|
gboolean
|
|
ges_track_element_set_track (GESTrackElement * object, GESTrack * track)
|
|
{
|
|
gboolean ret = TRUE;
|
|
|
|
g_return_val_if_fail (object->priv->nleobject, FALSE);
|
|
|
|
GST_DEBUG_OBJECT (object, "new track: %" GST_PTR_FORMAT, track);
|
|
|
|
object->priv->track = track;
|
|
|
|
if (object->priv->track) {
|
|
ges_track_element_set_track_type (object, track->type);
|
|
|
|
g_object_set (object->priv->nleobject,
|
|
"caps", ges_track_get_caps (object->priv->track), NULL);
|
|
}
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_TRACK]);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_all_control_bindings
|
|
* @trackelement: A #GESTrackElement
|
|
*
|
|
* Get all the control bindings that have been created for the children
|
|
* properties of the track element using
|
|
* ges_track_element_set_control_source(). The keys used in the returned
|
|
* hash table are the child property names that were passed to
|
|
* ges_track_element_set_control_source(), and their values are the
|
|
* corresponding created #GstControlBinding.
|
|
*
|
|
* Returns: (element-type gchar* GstControlBinding)(transfer none): A
|
|
* hash table containing all child-property-name/control-binding pairs
|
|
* for @trackelement.
|
|
*/
|
|
GHashTable *
|
|
ges_track_element_get_all_control_bindings (GESTrackElement * trackelement)
|
|
{
|
|
GESTrackElementPrivate *priv = GES_TRACK_ELEMENT (trackelement)->priv;
|
|
|
|
return priv->bindings_hashtable;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_track:
|
|
* @object: A #GESTrackElement
|
|
*
|
|
* Get the #GESTrackElement:track for the element.
|
|
*
|
|
* Returns: (transfer none) (nullable): The track that @object belongs to,
|
|
* or %NULL if it does not belong to a track.
|
|
*/
|
|
GESTrack *
|
|
ges_track_element_get_track (GESTrackElement * object)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
|
|
|
|
return object->priv->track;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_gnlobject:
|
|
* @object: A #GESTrackElement
|
|
*
|
|
* Get the GNonLin object this object is controlling.
|
|
*
|
|
* Returns: (transfer none): The GNonLin object this object is controlling.
|
|
*
|
|
* Deprecated: use #ges_track_element_get_nleobject instead.
|
|
*/
|
|
GstElement *
|
|
ges_track_element_get_gnlobject (GESTrackElement * object)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
|
|
|
|
return object->priv->nleobject;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_nleobject:
|
|
* @object: A #GESTrackElement
|
|
*
|
|
* Get the nleobject that this element wraps.
|
|
*
|
|
* Returns: (transfer none): The nleobject that @object wraps.
|
|
*
|
|
* Since: 1.6
|
|
*/
|
|
GstElement *
|
|
ges_track_element_get_nleobject (GESTrackElement * object)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
|
|
|
|
return object->priv->nleobject;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_element:
|
|
* @object: A #GESTrackElement
|
|
*
|
|
* Get the #GstElement that the track element's underlying nleobject
|
|
* controls.
|
|
*
|
|
* Returns: (transfer none): The #GstElement being controlled by the
|
|
* nleobject that @object wraps.
|
|
*/
|
|
GstElement *
|
|
ges_track_element_get_element (GESTrackElement * object)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
|
|
|
|
return object->priv->element;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_is_active:
|
|
* @object: A #GESTrackElement
|
|
*
|
|
* Gets #GESTrackElement:active for the element.
|
|
*
|
|
* Returns: %TRUE if @object is active in its track.
|
|
*/
|
|
gboolean
|
|
ges_track_element_is_active (GESTrackElement * object)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
|
|
g_return_val_if_fail (object->priv->nleobject, FALSE);
|
|
|
|
return object->active;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_lookup_child:
|
|
* @object: Object to lookup the property in
|
|
* @prop_name: Name of the property to look up. You can specify the name of the
|
|
* class as such: "ClassName::property-name", to guarantee that you get the
|
|
* proper GParamSpec in case various GstElement-s contain the same property
|
|
* name. If you don't do so, you will get the first element found, having
|
|
* this property and the and the corresponding GParamSpec.
|
|
* @element: (out) (allow-none) (transfer full): pointer to a #GstElement that
|
|
* takes the real object to set property on
|
|
* @pspec: (out) (allow-none) (transfer full): pointer to take the specification
|
|
* describing the property
|
|
*
|
|
* Looks up which @element and @pspec would be effected by the given @name. If various
|
|
* contained elements have this property name you will get the first one, unless you
|
|
* specify the class name in @name.
|
|
*
|
|
* Returns: TRUE if @element and @pspec could be found. FALSE otherwise. In that
|
|
* case the values for @pspec and @element are not modified. Unref @element after
|
|
* usage.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_lookup_child
|
|
*/
|
|
gboolean
|
|
ges_track_element_lookup_child (GESTrackElement * object,
|
|
const gchar * prop_name, GstElement ** element, GParamSpec ** pspec)
|
|
{
|
|
return ges_timeline_element_lookup_child (GES_TIMELINE_ELEMENT (object),
|
|
prop_name, ((GObject **) element), pspec);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_set_child_property_by_pspec: (skip):
|
|
* @object: A #GESTrackElement
|
|
* @pspec: The #GParamSpec that specifies the property you want to set
|
|
* @value: The value
|
|
*
|
|
* Sets a property of a child of @object.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_set_child_property_by_spec
|
|
*/
|
|
void
|
|
ges_track_element_set_child_property_by_pspec (GESTrackElement * object,
|
|
GParamSpec * pspec, GValue * value)
|
|
{
|
|
g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
|
|
|
|
ges_timeline_element_set_child_property_by_pspec (GES_TIMELINE_ELEMENT
|
|
(object), pspec, value);
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_set_child_property_valist: (skip):
|
|
* @object: The #GESTrackElement parent object
|
|
* @first_property_name: The name of the first property to set
|
|
* @var_args: Value for the first property, followed optionally by more
|
|
* name/return location pairs, followed by NULL
|
|
*
|
|
* Sets a property of a child of @object. If there are various child elements
|
|
* that have the same property name, you can distinguish them using the following
|
|
* syntax: 'ClasseName::property_name' as property name. If you don't, the
|
|
* corresponding property of the first element found will be set.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_set_child_property_valist
|
|
*/
|
|
void
|
|
ges_track_element_set_child_property_valist (GESTrackElement * object,
|
|
const gchar * first_property_name, va_list var_args)
|
|
{
|
|
ges_timeline_element_set_child_property_valist (GES_TIMELINE_ELEMENT (object),
|
|
first_property_name, var_args);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_set_child_properties: (skip):
|
|
* @object: The #GESTrackElement parent object
|
|
* @first_property_name: The name of the first property to set
|
|
* @...: value for the first property, followed optionally by more
|
|
* name/return location pairs, followed by NULL
|
|
*
|
|
* Sets a property of a child of @object. If there are various child elements
|
|
* that have the same property name, you can distinguish them using the following
|
|
* syntax: 'ClasseName::property_name' as property name. If you don't, the
|
|
* corresponding property of the first element found will be set.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_set_child_properties
|
|
*/
|
|
void
|
|
ges_track_element_set_child_properties (GESTrackElement * object,
|
|
const gchar * first_property_name, ...)
|
|
{
|
|
va_list var_args;
|
|
|
|
g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
|
|
|
|
va_start (var_args, first_property_name);
|
|
ges_track_element_set_child_property_valist (object, first_property_name,
|
|
var_args);
|
|
va_end (var_args);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_child_property_valist: (skip):
|
|
* @object: The #GESTrackElement parent object
|
|
* @first_property_name: The name of the first property to get
|
|
* @var_args: Value for the first property, followed optionally by more
|
|
* name/return location pairs, followed by NULL
|
|
*
|
|
* Gets a property of a child of @object. If there are various child elements
|
|
* that have the same property name, you can distinguish them using the following
|
|
* syntax: 'ClasseName::property_name' as property name. If you don't, the
|
|
* corresponding property of the first element found will be set.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_get_child_property_valist
|
|
*/
|
|
void
|
|
ges_track_element_get_child_property_valist (GESTrackElement * object,
|
|
const gchar * first_property_name, va_list var_args)
|
|
{
|
|
ges_timeline_element_get_child_property_valist (GES_TIMELINE_ELEMENT (object),
|
|
first_property_name, var_args);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_list_children_properties:
|
|
* @object: The #GESTrackElement to get the list of children properties from
|
|
* @n_properties: (out): return location for the length of the returned array
|
|
*
|
|
* Gets an array of #GParamSpec* for all configurable properties of the
|
|
* children of @object.
|
|
*
|
|
* Returns: (transfer full) (array length=n_properties): An array of #GParamSpec* which should be freed after use or
|
|
* %NULL if something went wrong.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_list_children_properties
|
|
*/
|
|
GParamSpec **
|
|
ges_track_element_list_children_properties (GESTrackElement * object,
|
|
guint * n_properties)
|
|
{
|
|
return
|
|
ges_timeline_element_list_children_properties (GES_TIMELINE_ELEMENT
|
|
(object), n_properties);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_child_properties: (skip):
|
|
* @object: The origin #GESTrackElement
|
|
* @first_property_name: The name of the first property to get
|
|
* @...: return location for the first property, followed optionally by more
|
|
* name/return location pairs, followed by NULL
|
|
*
|
|
* Gets properties of a child of @object.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_get_child_properties
|
|
*/
|
|
void
|
|
ges_track_element_get_child_properties (GESTrackElement * object,
|
|
const gchar * first_property_name, ...)
|
|
{
|
|
va_list var_args;
|
|
|
|
g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
|
|
|
|
va_start (var_args, first_property_name);
|
|
ges_track_element_get_child_property_valist (object, first_property_name,
|
|
var_args);
|
|
va_end (var_args);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_child_property_by_pspec: (skip):
|
|
* @object: A #GESTrackElement
|
|
* @pspec: The #GParamSpec that specifies the property you want to get
|
|
* @value: (out): return location for the value
|
|
*
|
|
* Gets a property of a child of @object.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_get_child_property_by_pspec
|
|
*/
|
|
void
|
|
ges_track_element_get_child_property_by_pspec (GESTrackElement * object,
|
|
GParamSpec * pspec, GValue * value)
|
|
{
|
|
ges_timeline_element_get_child_property_by_pspec (GES_TIMELINE_ELEMENT
|
|
(object), pspec, value);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_set_child_property: (skip):
|
|
* @object: The origin #GESTrackElement
|
|
* @property_name: The name of the property
|
|
* @value: The value
|
|
*
|
|
* Sets a property of a GstElement contained in @object.
|
|
*
|
|
* Note that #ges_track_element_set_child_property is really
|
|
* intended for language bindings, #ges_track_element_set_child_properties
|
|
* is much more convenient for C programming.
|
|
*
|
|
* Returns: %TRUE if the property was set, %FALSE otherwize.
|
|
*
|
|
* Deprecated: use #ges_timeline_element_set_child_property instead
|
|
*/
|
|
gboolean
|
|
ges_track_element_set_child_property (GESTrackElement * object,
|
|
const gchar * property_name, GValue * value)
|
|
{
|
|
return ges_timeline_element_set_child_property (GES_TIMELINE_ELEMENT (object),
|
|
property_name, value);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_child_property: (skip):
|
|
* @object: The origin #GESTrackElement
|
|
* @property_name: The name of the property
|
|
* @value: (out): return location for the property value, it will
|
|
* be initialized if it is initialized with 0
|
|
*
|
|
* In general, a copy is made of the property contents and
|
|
* the caller is responsible for freeing the memory by calling
|
|
* g_value_unset().
|
|
*
|
|
* Gets a property of a GstElement contained in @object.
|
|
*
|
|
* Note that #ges_track_element_get_child_property is really
|
|
* intended for language bindings, #ges_track_element_get_child_properties
|
|
* is much more convenient for C programming.
|
|
*
|
|
* Returns: %TRUE if the property was found, %FALSE otherwize.
|
|
*
|
|
* Deprecated: Use #ges_timeline_element_get_child_property
|
|
*/
|
|
gboolean
|
|
ges_track_element_get_child_property (GESTrackElement * object,
|
|
const gchar * property_name, GValue * value)
|
|
{
|
|
return ges_timeline_element_get_child_property (GES_TIMELINE_ELEMENT (object),
|
|
property_name, value);
|
|
}
|
|
|
|
void
|
|
ges_track_element_copy_properties (GESTimelineElement * element,
|
|
GESTimelineElement * elementcopy)
|
|
{
|
|
GParamSpec **specs;
|
|
guint n, n_specs;
|
|
GValue val = { 0 };
|
|
GESTrackElement *copy = GES_TRACK_ELEMENT (elementcopy);
|
|
|
|
specs =
|
|
ges_track_element_list_children_properties (GES_TRACK_ELEMENT (element),
|
|
&n_specs);
|
|
for (n = 0; n < n_specs; ++n) {
|
|
if (!(specs[n]->flags & G_PARAM_WRITABLE))
|
|
continue;
|
|
g_value_init (&val, specs[n]->value_type);
|
|
ges_track_element_get_child_property_by_pspec (GES_TRACK_ELEMENT (element),
|
|
specs[n], &val);
|
|
ges_track_element_set_child_property_by_pspec (copy, specs[n], &val);
|
|
g_value_unset (&val);
|
|
}
|
|
|
|
g_free (specs);
|
|
}
|
|
|
|
/* copy an element, as well as its GES_TRACK_ELEMENT_IS_CORE flag */
|
|
GESTrackElement *
|
|
ges_track_element_copy_core (GESTrackElement * self, gboolean deep)
|
|
{
|
|
GESTimelineElement *copy =
|
|
ges_timeline_element_copy (GES_TIMELINE_ELEMENT (self), deep);
|
|
if (!copy)
|
|
return NULL;
|
|
if (ELEMENT_FLAG_IS_SET (self, GES_TRACK_ELEMENT_IS_CORE))
|
|
ELEMENT_SET_FLAG (copy, GES_TRACK_ELEMENT_IS_CORE);
|
|
return GES_TRACK_ELEMENT (copy);
|
|
}
|
|
|
|
static void
|
|
_split_binding (GESTrackElement * element, GESTrackElement * new_element,
|
|
guint64 position, GstTimedValueControlSource * source,
|
|
GstTimedValueControlSource * new_source, gboolean absolute)
|
|
{
|
|
GstTimedValue *last_value = NULL;
|
|
gboolean past_position = FALSE;
|
|
GList *values, *tmp;
|
|
|
|
values =
|
|
gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE
|
|
(source));
|
|
|
|
for (tmp = values; tmp; tmp = tmp->next) {
|
|
GstTimedValue *value = tmp->data;
|
|
|
|
if (value->timestamp > position && !past_position) {
|
|
gfloat value_at_pos;
|
|
|
|
/* FIXME We should be able to use gst_control_source_get_value so
|
|
* all modes are handled. Right now that method only works if the value
|
|
* we are looking for is between two actual keyframes which is not enough
|
|
* in our case. bug #706621 */
|
|
value_at_pos =
|
|
interpolate_values_for_position (last_value, value, position,
|
|
absolute);
|
|
|
|
past_position = TRUE;
|
|
|
|
gst_timed_value_control_source_set (new_source, position, value_at_pos);
|
|
gst_timed_value_control_source_set (new_source, value->timestamp,
|
|
value->value);
|
|
|
|
gst_timed_value_control_source_unset (source, value->timestamp);
|
|
gst_timed_value_control_source_set (source, position, value_at_pos);
|
|
} else if (past_position) {
|
|
gst_timed_value_control_source_set (new_source, value->timestamp,
|
|
value->value);
|
|
gst_timed_value_control_source_unset (source, value->timestamp);
|
|
}
|
|
last_value = value;
|
|
|
|
}
|
|
g_list_free (values);
|
|
}
|
|
|
|
static void
|
|
_copy_binding (GESTrackElement * element, GESTrackElement * new_element,
|
|
guint64 position, GstTimedValueControlSource * source,
|
|
GstTimedValueControlSource * new_source, gboolean absolute)
|
|
{
|
|
GList *values, *tmp;
|
|
|
|
values =
|
|
gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE
|
|
(source));
|
|
for (tmp = values; tmp; tmp = tmp->next) {
|
|
GstTimedValue *value = tmp->data;
|
|
|
|
gst_timed_value_control_source_set (new_source, value->timestamp,
|
|
value->value);
|
|
}
|
|
g_list_free (values);
|
|
}
|
|
|
|
/* position == GST_CLOCK_TIME_NONE means that we do a simple copy
|
|
* other position means that the function will do a splitting
|
|
* and thus interpollate the values in the element and new_element
|
|
*/
|
|
void
|
|
ges_track_element_copy_bindings (GESTrackElement * element,
|
|
GESTrackElement * new_element, guint64 position)
|
|
{
|
|
GParamSpec **specs;
|
|
guint n, n_specs;
|
|
gboolean absolute;
|
|
GstControlBinding *binding;
|
|
GstTimedValueControlSource *source, *new_source;
|
|
|
|
specs =
|
|
ges_track_element_list_children_properties (GES_TRACK_ELEMENT (element),
|
|
&n_specs);
|
|
for (n = 0; n < n_specs; ++n) {
|
|
GstInterpolationMode mode;
|
|
|
|
binding = ges_track_element_get_control_binding (element, specs[n]->name);
|
|
if (!binding)
|
|
continue;
|
|
|
|
g_object_get (binding, "control_source", &source, NULL);
|
|
if (!GST_IS_TIMED_VALUE_CONTROL_SOURCE (source)) {
|
|
GST_FIXME_OBJECT (element,
|
|
"Implement support for control source type: %s",
|
|
G_OBJECT_TYPE_NAME (source));
|
|
continue;
|
|
}
|
|
|
|
g_object_get (binding, "absolute", &absolute, NULL);
|
|
g_object_get (source, "mode", &mode, NULL);
|
|
|
|
new_source =
|
|
GST_TIMED_VALUE_CONTROL_SOURCE (gst_interpolation_control_source_new
|
|
());
|
|
g_object_set (new_source, "mode", mode, NULL);
|
|
|
|
if (GST_CLOCK_TIME_IS_VALID (position))
|
|
_split_binding (element, new_element, position, source, new_source,
|
|
absolute);
|
|
else
|
|
_copy_binding (element, new_element, position, source, new_source,
|
|
absolute);
|
|
|
|
/* We only manage direct (absolute) bindings, see TODO in set_control_source */
|
|
if (absolute)
|
|
ges_track_element_set_control_source (new_element,
|
|
GST_CONTROL_SOURCE (new_source), specs[n]->name, "direct-absolute");
|
|
else
|
|
ges_track_element_set_control_source (new_element,
|
|
GST_CONTROL_SOURCE (new_source), specs[n]->name, "direct");
|
|
}
|
|
|
|
g_free (specs);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_edit:
|
|
* @object: The #GESTrackElement to edit
|
|
* @layers: (element-type GESLayer) (nullable): A whitelist of layers
|
|
* where the edit can be performed, %NULL allows all layers in the
|
|
* timeline
|
|
* @mode: The edit mode
|
|
* @edge: The edge of @object where the edit should occur
|
|
* @position: The edit position: a new location for the edge of @object
|
|
* (in nanoseconds)
|
|
*
|
|
* Edits the element within its track.
|
|
*
|
|
* Returns: %TRUE if the edit of @object completed, %FALSE on failure.
|
|
*
|
|
* Deprecated: 1.18: use #ges_timeline_element_edit instead.
|
|
*/
|
|
gboolean
|
|
ges_track_element_edit (GESTrackElement * object,
|
|
GList * layers, GESEditMode mode, GESEdge edge, guint64 position)
|
|
{
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
|
|
|
|
return ges_timeline_element_edit (GES_TIMELINE_ELEMENT (object),
|
|
layers, -1, mode, edge, position);
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_remove_control_binding:
|
|
* @object: A #GESTrackElement
|
|
* @property_name: The name of the child property to remove the control
|
|
* binding from
|
|
*
|
|
* Removes the #GstControlBinding that was created for the specified child
|
|
* property of the track element using
|
|
* ges_track_element_set_control_source(). The given @property_name must
|
|
* be the same name of the child property that was passed to
|
|
* ges_track_element_set_control_source().
|
|
*
|
|
* Returns: %TRUE if the control binding was removed from the specified
|
|
* child property of @object, or %FALSE if an error occurred.
|
|
*/
|
|
gboolean
|
|
ges_track_element_remove_control_binding (GESTrackElement * object,
|
|
const gchar * property_name)
|
|
{
|
|
GESTrackElementPrivate *priv;
|
|
GstControlBinding *binding;
|
|
GstObject *target;
|
|
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
|
|
|
|
priv = GES_TRACK_ELEMENT (object)->priv;
|
|
binding =
|
|
(GstControlBinding *) g_hash_table_lookup (priv->bindings_hashtable,
|
|
property_name);
|
|
|
|
if (binding) {
|
|
g_object_get (binding, "object", &target, NULL);
|
|
GST_DEBUG_OBJECT (object, "Removing binding %p for property %s", binding,
|
|
property_name);
|
|
|
|
gst_object_ref (binding);
|
|
gst_object_remove_control_binding (target, binding);
|
|
|
|
g_signal_emit (object, ges_track_element_signals[CONTROL_BINDING_REMOVED],
|
|
0, binding);
|
|
|
|
gst_object_unref (target);
|
|
gst_object_unref (binding);
|
|
g_hash_table_remove (priv->bindings_hashtable, property_name);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_set_control_source:
|
|
* @object: A #GESTrackElement
|
|
* @source: The control source to bind the child property to
|
|
* @property_name: The name of the child property to control
|
|
* @binding_type: The type of binding to create ("direct" or
|
|
* "direct-absolute")
|
|
*
|
|
* Creates a #GstControlBinding for the specified child property of the
|
|
* track element using the given control source. The given @property_name
|
|
* should refer to an existing child property of the track element, as
|
|
* used in ges_timeline_element_lookup_child().
|
|
*
|
|
* If @binding_type is "direct", then the control binding is created with
|
|
* gst_direct_control_binding_new() using the given control source. If
|
|
* @binding_type is "direct-absolute", it is created with
|
|
* gst_direct_control_binding_new_absolute() instead.
|
|
*
|
|
* Returns: %TRUE if the specified child property could be bound to
|
|
* @source, or %FALSE if an error occurred.
|
|
*/
|
|
gboolean
|
|
ges_track_element_set_control_source (GESTrackElement * object,
|
|
GstControlSource * source,
|
|
const gchar * property_name, const gchar * binding_type)
|
|
{
|
|
GESTrackElementPrivate *priv;
|
|
GstElement *element;
|
|
GParamSpec *pspec;
|
|
GstControlBinding *binding;
|
|
gboolean direct, direct_absolute;
|
|
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
|
|
priv = GES_TRACK_ELEMENT (object)->priv;
|
|
|
|
if (G_UNLIKELY (!(GST_IS_CONTROL_SOURCE (source)))) {
|
|
GST_WARNING
|
|
("You need to provide a non-null control source to build a new control binding");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!ges_track_element_lookup_child (object, property_name, &element, &pspec)) {
|
|
GST_WARNING ("You need to provide a valid and controllable property name");
|
|
return FALSE;
|
|
}
|
|
|
|
/* TODO : update this according to new types of bindings */
|
|
direct = !g_strcmp0 (binding_type, "direct");
|
|
direct_absolute = !g_strcmp0 (binding_type, "direct-absolute");
|
|
|
|
if (direct || direct_absolute) {
|
|
/* First remove existing binding */
|
|
if (ges_track_element_remove_control_binding (object, property_name)) {
|
|
GST_LOG ("Removed old binding for property %s", property_name);
|
|
}
|
|
|
|
if (direct_absolute)
|
|
binding =
|
|
gst_direct_control_binding_new_absolute (GST_OBJECT (element),
|
|
property_name, source);
|
|
else
|
|
binding =
|
|
gst_direct_control_binding_new (GST_OBJECT (element), property_name,
|
|
source);
|
|
|
|
gst_object_add_control_binding (GST_OBJECT (element), binding);
|
|
/* FIXME: maybe we should force the
|
|
* "ChildTypeName:property-name"
|
|
* format convention for child property names in bindings_hashtable.
|
|
* Currently the table may also contain
|
|
* "property-name"
|
|
* as keys.
|
|
*/
|
|
g_hash_table_insert (priv->bindings_hashtable, g_strdup (property_name),
|
|
binding);
|
|
g_signal_emit (object, ges_track_element_signals[CONTROL_BINDING_ADDED],
|
|
0, binding);
|
|
return TRUE;
|
|
}
|
|
|
|
GST_WARNING ("Binding type must be in [direct]");
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* ges_track_element_get_control_binding:
|
|
* @object: A #GESTrackElement
|
|
* @property_name: The name of the child property to return the control
|
|
* binding of
|
|
*
|
|
* Gets the control binding that was created for the specified child
|
|
* property of the track element using
|
|
* ges_track_element_set_control_source(). The given @property_name must
|
|
* be the same name of the child property that was passed to
|
|
* ges_track_element_set_control_source().
|
|
*
|
|
* Returns: (transfer none) (nullable): The control binding that was
|
|
* created for the specified child property of @object, or %NULL if
|
|
* @property_name does not correspond to any control binding.
|
|
*/
|
|
GstControlBinding *
|
|
ges_track_element_get_control_binding (GESTrackElement * object,
|
|
const gchar * property_name)
|
|
{
|
|
GESTrackElementPrivate *priv;
|
|
GstControlBinding *binding;
|
|
|
|
g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
|
|
|
|
priv = GES_TRACK_ELEMENT (object)->priv;
|
|
|
|
binding =
|
|
(GstControlBinding *) g_hash_table_lookup (priv->bindings_hashtable,
|
|
property_name);
|
|
return binding;
|
|
}
|