mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-09-29 07:12:36 +00:00
Code Issues 1 Projects Releases Wiki Activity

Rename object/tobj/trobj to clip or track_element as necessary

Browse source 
Not really complete but it is a good start!
This commit is contained in:
Thibault Saunier 2013-02-14 23:34:48 -03:00
parent 7f3c952737
commit 0888e5e25b
35 changed files with 1320 additions and 1316 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
ges/ges-audio-transition.c
View file

@ -159,7 +159,7 @@ link_element_to_mixer_with_volume (GstBin * bin, GstElement * element,
}
static GstElement *
ges_audio_transition_create_element (GESTrackElement * object)
ges_audio_transition_create_element (GESTrackElement * track_element)
{
GESAudioTransition *self;
GstElement *topbin, *iconva, *iconvb, *oconv;
@ -169,7 +169,7 @@ ges_audio_transition_create_element (GESTrackElement * object)
GstPad *sinka_target, *sinkb_target, *src_target, *sinka, *sinkb, *src;
GstControlSource *acontrol_source, *bcontrol_source;
self = GES_AUDIO_TRANSITION (object);
self = GES_AUDIO_TRANSITION (track_element);
GST_LOG ("creating an audio bin");
@ -228,14 +228,14 @@ ges_audio_transition_create_element (GESTrackElement * object)
}
static void
ges_audio_transition_duration_changed (GESTrackElement * object,
ges_audio_transition_duration_changed (GESTrackElement * track_element,
guint64 duration)
{
GESAudioTransition *self;
GstElement *gnlobj = ges_track_element_get_gnlobject (object);
GstElement *gnlobj = ges_track_element_get_gnlobject (track_element);
GstTimedValueControlSource *ta, *tb;
self = GES_AUDIO_TRANSITION (object);
self = GES_AUDIO_TRANSITION (track_element);
GST_LOG ("updating controller: gnlobj (%p)", gnlobj);

12
ges/ges-auto-transition.c
View file

@ -36,7 +36,7 @@ static guint auto_transition_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (GESAutoTransition, ges_auto_transition, G_TYPE_OBJECT);
static void
neighbour_changed_cb (GESClip * obj, GParamSpec * arg G_GNUC_UNUSED,
neighbour_changed_cb (GESClip * clip, GParamSpec * arg G_GNUC_UNUSED,
GESAutoTransition * self)
{
gint64 new_duration;
@ -67,7 +67,7 @@ neighbour_changed_cb (GESClip * obj, GParamSpec * arg G_GNUC_UNUSED,
}
static void
_height_changed_cb (GESClip * obj, GParamSpec * arg G_GNUC_UNUSED,
_height_changed_cb (GESClip * clip, GParamSpec * arg G_GNUC_UNUSED,
GESAutoTransition * self)
{
/* FIXME This is really not smart and we should properly implement clip
@ -77,12 +77,12 @@ _height_changed_cb (GESClip * obj, GParamSpec * arg G_GNUC_UNUSED,
}
static void
_track_changed_cb (GESTrackElement * obj, GParamSpec * arg G_GNUC_UNUSED,
GESAutoTransition * self)
_track_changed_cb (GESTrackElement * track_element,
GParamSpec * arg G_GNUC_UNUSED, GESAutoTransition * self)
{
if (ges_track_element_get_track (obj) == NULL) {
if (ges_track_element_get_track (track_element) == NULL) {
GST_DEBUG_OBJECT (self, "Neighboor %" GST_PTR_FORMAT
" removed from track ... auto destructing", obj);
" removed from track ... auto destructing", track_element);
g_signal_emit (self, auto_transition_signals[DESTROY_ME], 0);
}

6
ges/ges-base-xml-formatter.c
View file

@ -680,7 +680,7 @@ ges_base_xml_formatter_add_clip (GESBaseXmlFormatter * self,
const gchar * metadatas, GError ** error)
{
GESAsset *asset;
GESClip *nobj;
GESClip *nclip;
LayerEntry *entry;
GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self);
@ -742,11 +742,11 @@ ges_base_xml_formatter_add_clip (GESBaseXmlFormatter * self,
return;
}
nobj = _add_object_to_layer (priv, id, entry->layer,
nclip = _add_object_to_layer (priv, id, entry->layer,
asset, start, inpoint, duration, rate, track_types, metadatas,
properties);
if (!nobj)
if (!nclip)
return;
}

630
ges/ges-clip.c
View file

File diff suppressed because it is too large Load diff

78
ges/ges-clip.h
View file

@ -40,8 +40,8 @@ typedef struct _GESClipPrivate GESClipPrivate;
/**
* GESFillTrackElementFunc:
* @object: the #GESClip controlling the track elements
* @trobject: the #GESTrackElement
* @clip: the #GESClip controlling the track elements
* @track_element: the #GESTrackElement
* @gnlobj: the GNonLin object that needs to be filled.
*
* A function that will be called when the GNonLin object of a corresponding
@ -52,16 +52,16 @@ typedef struct _GESClipPrivate GESClipPrivate;
*
* Returns: TRUE if the implementer succesfully filled the @gnlobj, else #FALSE.
*/
typedef gboolean (*GESFillTrackElementFunc) (GESClip *object,
GESTrackElement *trobject,
typedef gboolean (*GESFillTrackElementFunc) (GESClip *clip,
GESTrackElement *track_element,
GstElement *gnlobj);
/**
* GESCreateTrackElementFunc:
* @object: a #GESClip
* @clip: a #GESClip
* @type: a #GESTrackType
*
* Creates the 'primary' track element for this @object.
* Creates the 'primary' track element for this @clip.
*
* Subclasses should implement this method if they only provide a
* single #GESTrackElement per track.
@ -71,7 +71,7 @@ typedef gboolean (*GESFillTrackElementFunc) (GESClip *object,
* method instead.
*
* The implementer of this function shall return the proper #GESTrackElement
* that should be controlled by @object for the given @track.
* that should be controlled by @clip for the given @track.
*
* The returned #GESTrackElement will be automatically added to the list
* of objects controlled by the #GESClip.
@ -79,33 +79,33 @@ typedef gboolean (*GESFillTrackElementFunc) (GESClip *object,
* Returns: the #GESTrackElement to be used, or %NULL if it can't provide one
* for the given @track.
*/
typedef GESTrackElement *(*GESCreateTrackElementFunc) (GESClip * object,
typedef GESTrackElement *(*GESCreateTrackElementFunc) (GESClip * clip,
GESTrackType type);
/**
* GESCreateTrackElementsFunc:
* @object: a #GESClip
* @clip: a #GESClip
* @type: a #GESTrackType
*
* Create all track elements this object handles for this type of track.
* Create all track elements this clip handles for this type of track.
*
* Subclasses should implement this method if they potentially need to
* return more than one #GESTrackElement(s) for a given #GESTrack.
*
* For each object created, the subclass must call
* ges_clip_add_track_element() with the newly created object
* For each clip created, the subclass must call
* ges_clip_add_track_element() with the newly created clip
* and provided @type.
*
* Returns: %TRUE on success %FALSE on failure.
*/
typedef GList * (*GESCreateTrackElementsFunc) (GESClip * object, GESTrackType type);
typedef GList * (*GESCreateTrackElementsFunc) (GESClip * clip, GESTrackType type);
/**
* GES_CLIP_HEIGHT:
* @obj: a #GESClip
*
* The span of priorities this object occupies.
* The span of priorities this clip occupies.
*/
#define GES_CLIP_HEIGHT(obj) (((GESClip*)obj)->height)
@ -125,8 +125,8 @@ struct _GESClip
/* We don't add those properties to the priv struct for optimization purposes
* start, inpoint, duration and fullduration are in nanoseconds */
guint32 height; /* the span of priorities this object needs */
guint64 fullduration; /* Full usable duration of the object (-1: no duration) */
guint32 height; /* the span of priorities this clip needs */
guint64 fullduration; /* Full usable duration of the clip (-1: no duration) */
/*< private >*/
GESClipPrivate *priv;
@ -166,9 +166,9 @@ struct _GESClipClass
gboolean need_fill_track;
gboolean snaps;
void (*track_element_added) (GESClip *object,
void (*track_element_added) (GESClip *clip,
GESTrackElement *track_element);
void (*track_element_released) (GESClip *object,
void (*track_element_released) (GESClip *clip,
GESTrackElement *track_element);
/*< private >*/
@ -179,37 +179,37 @@ struct _GESClipClass
GType ges_clip_get_type (void);
/* Setters */
void ges_clip_set_layer (GESClip *object,
void ges_clip_set_layer (GESClip *clip,
GESTimelineLayer *layer);
/* TrackElement handling */
GList* ges_clip_get_track_elements (GESClip *object);
GESTrackType ges_clip_get_supported_formats (GESClip *object);
GESTrackElement *ges_clip_create_track_element (GESClip *object, GESTrackType type);
GList * ges_clip_create_track_elements (GESClip *object, GESTrackType type);
gboolean ges_clip_release_track_element (GESClip *object, GESTrackElement *trackelement);
void ges_clip_set_supported_formats (GESClip *object, GESTrackType supportedformats);
gboolean ges_clip_add_asset (GESClip *object, GESAsset *asset);
gboolean ges_clip_add_track_element (GESClip *object, GESTrackElement *trobj);
gboolean ges_clip_fill_track_element (GESClip *object, GESTrackElement *trackelement, GstElement *gnlobj);
GESTrackElement *ges_clip_find_track_element (GESClip *object, GESTrack *track, GType type);
GList* ges_clip_get_track_elements (GESClip *clip);
GESTrackType ges_clip_get_supported_formats (GESClip *clip);
GESTrackElement *ges_clip_create_track_element (GESClip *clip, GESTrackType type);
GList * ges_clip_create_track_elements (GESClip *clip, GESTrackType type);
gboolean ges_clip_release_track_element (GESClip *clip, GESTrackElement *trackelement);
void ges_clip_set_supported_formats (GESClip *clip, GESTrackType supportedformats);
gboolean ges_clip_add_asset (GESClip *clip, GESAsset *asset);
gboolean ges_clip_add_track_element (GESClip *clip, GESTrackElement *track_element);
gboolean ges_clip_fill_track_element (GESClip *clip, GESTrackElement *trackelement, GstElement *gnlobj);
GESTrackElement *ges_clip_find_track_element (GESClip *clip, GESTrack *track, GType type);
/* Layer */
GESTimelineLayer *ges_clip_get_layer (GESClip *object);
gboolean ges_clip_is_moving_from_layer (GESClip *object);
gboolean ges_clip_move_to_layer (GESClip *object, GESTimelineLayer *layer);
void ges_clip_set_moving_from_layer (GESClip *object, gboolean is_moving);
GESTimelineLayer *ges_clip_get_layer (GESClip *clip);
gboolean ges_clip_is_moving_from_layer (GESClip *clip);
gboolean ges_clip_move_to_layer (GESClip *clip, GESTimelineLayer *layer);
void ges_clip_set_moving_from_layer (GESClip *clip, gboolean is_moving);
/* Effects */
GList* ges_clip_get_top_effects (GESClip *object);
gint ges_clip_get_top_effect_position (GESClip *object, GESBaseEffect *effect);
gboolean ges_clip_set_top_effect_priority (GESClip *object, GESBaseEffect *effect, guint newpriority);
GList* ges_clip_get_top_effects (GESClip *clip);
gint ges_clip_get_top_effect_position (GESClip *clip, GESBaseEffect *effect);
gboolean ges_clip_set_top_effect_priority (GESClip *clip, GESBaseEffect *effect, guint newpriority);
/* Editing */
GESClip *ges_clip_split (GESClip *object, guint64 position);
void ges_clip_objects_set_locked (GESClip *object, gboolean locked);
GESClip *ges_clip_split (GESClip *clip, guint64 position);
void ges_clip_objects_set_locked (GESClip *clip, gboolean locked);
gboolean ges_clip_edit (GESClip *object, GList *layers,
gboolean ges_clip_edit (GESClip *clip, GList *layers,
gint new_layer_priority, GESEditMode mode,
GESEdge edge, guint64 position);

17
ges/ges-custom-source-clip.c
View file

@ -130,11 +130,11 @@ ges_extractable_interface_init (GESExtractableInterface * iface)
}
static gboolean
ges_custom_source_clip_fill_track_element (GESClip * object,
GESTrackElement * trobject, GstElement * gnlobj);
ges_custom_source_clip_fill_track_element (GESClip * clip,
GESTrackElement * track_element, GstElement * gnlobj);
static GESTrackElement *
ges_custom_source_clip_create_track_element (GESClip * obj, GESTrackType type)
ges_custom_source_clip_create_track_element (GESClip * clip, GESTrackType type)
{
return g_object_new (GES_TYPE_SOURCE, "track-type", type, NULL);
}
@ -199,17 +199,18 @@ ges_custom_source_clip_init (GESCustomSourceClip * self)
}
static gboolean
ges_custom_source_clip_fill_track_element (GESClip * object,
GESTrackElement * trobject, GstElement * gnlobj)
ges_custom_source_clip_fill_track_element (GESClip * clip,
GESTrackElement * track_element, GstElement * gnlobj)
{
gboolean res;
GESCustomSourceClipPrivate *priv;
GST_DEBUG ("Calling callback (timelineobj:%p, trackelement:%p, gnlobj:%p)",
object, trobject, gnlobj);
clip, track_element, gnlobj);
priv = GES_CUSTOM_SOURCE_CLIP (object)->priv;
res = priv->filltrackelementfunc (object, trobject, gnlobj, priv->user_data);
priv = GES_CUSTOM_SOURCE_CLIP (clip)->priv;
res = priv->filltrackelementfunc (clip, track_element, gnlobj,
priv->user_data);
GST_DEBUG ("Returning res:%d", res);

4
ges/ges-custom-source-clip.h
View file

@ -49,7 +49,7 @@ typedef struct _GESCustomSourceClipPrivate GESCustomSourceClipPrivate;
/**
* GESFillTrackElementUserFunc:
* @object: the #GESClip controlling the track element
* @trobject: the #GESTrackElement
* @track_element: the #GESTrackElement
* @gnlobj: the GNonLin object that needs to be filled.
* @user_data: the gpointer to optional user data
*
@ -62,7 +62,7 @@ typedef struct _GESCustomSourceClipPrivate GESCustomSourceClipPrivate;
* Returns: TRUE if the implementer succesfully filled the @gnlobj, else #FALSE.
*/
typedef gboolean (*GESFillTrackElementUserFunc) (GESClip * object,
GESTrackElement * trobject,
GESTrackElement * track_element,
GstElement * gnlobj,
gpointer user_data);

4
ges/ges-image-source.c
View file

@ -110,7 +110,7 @@ pad_added_cb (GstElement * timeline, GstPad * pad, GstElement * scale)
}
static GstElement *
ges_image_source_create_element (GESTrackElement * object)
ges_image_source_create_element (GESTrackElement * track_element)
{
GstElement *bin, *source, *scale, *freeze, *iconv;
GstPad *src, *target;
@ -138,7 +138,7 @@ ges_image_source_create_element (GESTrackElement * object)
gst_element_add_pad (bin, src);
gst_object_unref (target);
g_object_set (source, "uri", ((GESImageSource *) object)->uri, NULL);
g_object_set (source, "uri", ((GESImageSource *) track_element)->uri, NULL);
g_signal_connect (G_OBJECT (source), "pad-added",
G_CALLBACK (pad_added_cb), scale);

22
ges/ges-pitivi-formatter.c
View file

@ -49,7 +49,7 @@ GST_DEBUG_CATEGORY_STATIC (ges_pitivi_formatter_debug);
typedef struct SrcMapping
{
gchar *id;
GESClip *obj;
GESClip *clip;
guint priority;
GList *track_element_ids;
} SrcMapping;
@ -96,7 +96,7 @@ static void
free_src_map (SrcMapping * srcmap)
{
g_free (srcmap->id);
g_object_unref (srcmap->obj);
g_object_unref (srcmap->clip);
g_list_foreach (srcmap->track_element_ids, (GFunc) g_free, NULL);
g_list_free (srcmap->track_element_ids);
g_slice_free (SrcMapping, srcmap);
@ -158,15 +158,15 @@ save_track_elements (xmlTextWriterPtr writer, GList * source_list,
GST_DEBUG ("Saving track elements");
for (tmp = source_list; tmp; tmp = tmp->next) {
SrcMapping *srcmap;
GESClip *object;
GESClip *clip;
guint i, j;
guint64 inpoint, duration, start;
srcmap = (SrcMapping *) tmp->data;
object = srcmap->obj;
clip = srcmap->clip;
/* Save track associated objects */
track_elements = ges_clip_get_track_elements (object);
track_elements = ges_clip_get_track_elements (clip);
for (tmp_tck = track_elements; tmp_tck; tmp_tck = tmp_tck->next) {
xmlChar *cast;
GESTrackElement *trackelement = GES_TRACK_ELEMENT (tmp_tck->data);
@ -388,7 +388,7 @@ save_sources (GESPitiviFormatter * formatter, GList * layers,
srcmap->id =
g_strdup (g_hash_table_lookup (priv->saving_source_table,
uriclip_uri));
srcmap->obj = g_object_ref (clip);
srcmap->clip = g_object_ref (clip);
srcmap->priority = ges_timeline_layer_get_priority (layer);
/* We fill up the track_element_ids in save_track_elements */
source_list = g_list_append (source_list, srcmap);
@ -748,7 +748,7 @@ set_properties (GObject * obj, GHashTable * props_table)
}
static void
track_element_added_cb (GESClip * object,
track_element_added_cb (GESClip * clip,
GESTrackElement * track_element, GHashTable * props_table)
{
gchar *media_type = NULL, *lockedstr;
@ -759,7 +759,7 @@ track_element_added_cb (GESClip * object,
gint type = 0;
GESPitiviFormatter *formatter;
track_elements = ges_clip_get_track_elements (object);
track_elements = ges_clip_get_track_elements (clip);
media_type = (gchar *) g_hash_table_lookup (props_table, "media_type");
lockedstr = (gchar *) g_hash_table_lookup (props_table, "locked");
@ -773,7 +773,7 @@ track_element_added_cb (GESClip * object,
* doesn't break everything */
g_hash_table_steal (props_table, "current-formatter");
priv->sources_to_load = g_list_remove (priv->sources_to_load, object);
priv->sources_to_load = g_list_remove (priv->sources_to_load, clip);
if (!priv->sources_to_load && GES_FORMATTER (formatter)->project)
ges_project_set_loaded (GES_FORMATTER (formatter)->project,
GES_FORMATTER (formatter));
@ -819,7 +819,7 @@ track_element_added_cb (GESClip * object,
}
if (has_effect) {
track_elements = ges_clip_get_track_elements (object);
track_elements = ges_clip_get_track_elements (clip);
/* FIXME make sure this is the way we want to handle that
* ie: set duration and start as the other trackelement
@ -841,7 +841,7 @@ track_element_added_cb (GESClip * object,
}
/* Disconnect the signal */
g_signal_handlers_disconnect_by_func (object, track_element_added_cb,
g_signal_handlers_disconnect_by_func (clip, track_element_added_cb,
props_table);
}

118
ges/ges-simple-timeline-layer.c
View file

@ -38,14 +38,14 @@
static void
ges_simple_timeline_layer_object_removed (GESTimelineLayer * layer,
GESClip * object);
GESClip * clip);
static void
ges_simple_timeline_layer_object_added (GESTimelineLayer * layer,
GESClip * object);
GESClip * clip);
static void
clip_height_changed_cb (GESClip * object G_GNUC_UNUSED,
clip_height_changed_cb (GESClip * clip G_GNUC_UNUSED,
GParamSpec * arg G_GNUC_UNUSED, GESSimpleTimelineLayer * layer);
static GList *get_objects (GESTimelineLayer * layer);
@ -179,24 +179,24 @@ gstl_recalculate (GESSimpleTimelineLayer * self)
}
for (tmp = priv->objects; tmp; tmp = tmp->next) {
GESClip *obj;
GESClip *clip;
guint64 dur;
GList *l_next;
obj = (GESClip *) tmp->data;
dur = _DURATION (obj);
height = GES_CLIP_HEIGHT (obj);
clip = (GESClip *) tmp->data;
dur = _DURATION (clip);
height = GES_CLIP_HEIGHT (clip);
if (GES_IS_SOURCE_CLIP (obj)) {
if (GES_IS_SOURCE_CLIP (clip)) {
GST_LOG ("%p obj: height: %d: priority %d", obj, height, priority);
GST_LOG ("%p clip: height: %d: priority %d", clip, height, priority);
if (G_UNLIKELY (_START (obj) != pos)) {
_set_start0 (GES_TIMELINE_ELEMENT (obj), pos);
if (G_UNLIKELY (_START (clip) != pos)) {
_set_start0 (GES_TIMELINE_ELEMENT (clip), pos);
}
if (G_UNLIKELY (_PRIORITY (obj) != priority)) {
_set_priority0 (GES_TIMELINE_ELEMENT (obj), priority);
if (G_UNLIKELY (_PRIORITY (clip) != priority)) {
_set_priority0 (GES_TIMELINE_ELEMENT (clip), priority);
}
transition_priority = MAX (0, priority - 1);
@ -205,23 +205,23 @@ gstl_recalculate (GESSimpleTimelineLayer * self)
g_assert (priority != -1);
} else if (GES_IS_BASE_TRANSITION_CLIP (obj)) {
} else if (GES_IS_BASE_TRANSITION_CLIP (clip)) {
pos -= dur;
if (pos < 0)
pos = 0;
GST_LOG ("%p obj: height: %d: trans_priority %d Position: %"
G_GINT64_FORMAT ", duration %" G_GINT64_FORMAT, obj, height,
GST_LOG ("%p clip: height: %d: trans_priority %d Position: %"
G_GINT64_FORMAT ", duration %" G_GINT64_FORMAT, clip, height,
transition_priority, pos, dur);
g_assert (transition_priority != -1);
if (G_UNLIKELY (_START (obj) != pos))
_set_start0 (GES_TIMELINE_ELEMENT (obj), pos);
if (G_UNLIKELY (_START (clip) != pos))
_set_start0 (GES_TIMELINE_ELEMENT (clip), pos);
if (G_UNLIKELY (_PRIORITY (obj) != transition_priority)) {
_set_priority0 (GES_TIMELINE_ELEMENT (obj), transition_priority);
if (G_UNLIKELY (_PRIORITY (clip) != transition_priority)) {
_set_priority0 (GES_TIMELINE_ELEMENT (clip), transition_priority);
}
/* sanity checks */
@ -254,10 +254,10 @@ gstl_recalculate (GESSimpleTimelineLayer * self)
valid = FALSE;
}
}
prev_transition = obj;
prev_transition = clip;
}
prev_object = obj;
prev_object = clip;
}
@ -297,17 +297,17 @@ gstl_recalculate (GESSimpleTimelineLayer * self)
*/
gboolean
ges_simple_timeline_layer_add_object (GESSimpleTimelineLayer * layer,
GESClip * object, gint position)
GESClip * clip, gint position)
{
gboolean res;
GList *nth;
GESSimpleTimelineLayerPrivate *priv = layer->priv;
GST_DEBUG ("layer:%p, object:%p, position:%d", layer, object, position);
GST_DEBUG ("layer:%p, clip:%p, position:%d", layer, clip, position);
nth = g_list_nth (priv->objects, position);
if (GES_IS_BASE_TRANSITION_CLIP (object)) {
if (GES_IS_BASE_TRANSITION_CLIP (clip)) {
GList *lprev = g_list_previous (nth);
GESClip *prev = GES_CLIP (lprev ? lprev->data : NULL);
@ -324,25 +324,25 @@ ges_simple_timeline_layer_add_object (GESSimpleTimelineLayer * layer,
priv->adding_object = TRUE;
/* provisionally insert the object */
priv->objects = g_list_insert (priv->objects, object, position);
/* provisionally insert the clip */
priv->objects = g_list_insert (priv->objects, clip, position);
res = ges_timeline_layer_add_clip ((GESTimelineLayer *) layer, object);
res = ges_timeline_layer_add_clip ((GESTimelineLayer *) layer, clip);
/* Add to layer */
if (G_UNLIKELY (!res)) {
priv->adding_object = FALSE;
/* we failed to add the object, so remove it from our list */
priv->objects = g_list_remove (priv->objects, object);
/* we failed to add the clip, so remove it from our list */
priv->objects = g_list_remove (priv->objects, clip);
return FALSE;
}
priv->adding_object = FALSE;
GST_DEBUG ("Adding object %p to the list", object);
GST_DEBUG ("Adding clip %p to the list", clip);
g_signal_connect (G_OBJECT (object), "notify::height", G_CALLBACK
g_signal_connect (G_OBJECT (clip), "notify::height", G_CALLBACK
(clip_height_changed_cb), layer);
/* recalculate positions */
@ -379,46 +379,45 @@ ges_simple_timeline_layer_nth (GESSimpleTimelineLayer * layer, gint position)
/**
* ges_simple_timeline_layer_index:
* @layer: a #GESSimpleTimelineLayer
* @object: a #GESClip in the layer
* @clip: a #GESClip in the layer
*
* Gets the position of the given object within the given layer.
* Gets the position of the given clip within the given layer.
*
* Returns: The position of the object starting from 0, or -1 if the
* object was not found.
* Returns: The position of the clip starting from 0, or -1 if the
* clip was not found.
*/
gint
ges_simple_timeline_layer_index (GESSimpleTimelineLayer * layer,
GESClip * object)
ges_simple_timeline_layer_index (GESSimpleTimelineLayer * layer, GESClip * clip)
{
GESSimpleTimelineLayerPrivate *priv = layer->priv;
return g_list_index (priv->objects, object);
return g_list_index (priv->objects, clip);
}
/**
* ges_simple_timeline_layer_move_object:
* @layer: a #GESSimpleTimelineLayer
* @object: the #GESClip to move
* @newposition: the new position at which to move the object
* @clip: the #GESClip to move
* @newposition: the new position at which to move the clip
*
* Moves the object to the given position in the layer. To put the object before
* Moves the clip to the given position in the layer. To put the clip before
* all other objects, use position 0. To put the objects after all objects, use
* position -1.
*
* Returns: TRUE if the object was successfuly moved, else FALSE.
* Returns: TRUE if the clip was successfuly moved, else FALSE.
*/
gboolean
ges_simple_timeline_layer_move_object (GESSimpleTimelineLayer * layer,
GESClip * object, gint newposition)
GESClip * clip, gint newposition)
{
gint idx;
GESSimpleTimelineLayerPrivate *priv = layer->priv;
GESTimelineLayer *clip_layer;
GST_DEBUG ("layer:%p, object:%p, newposition:%d", layer, object, newposition);
GST_DEBUG ("layer:%p, clip:%p, newposition:%d", layer, clip, newposition);
clip_layer = ges_clip_get_layer (object);
clip_layer = ges_clip_get_layer (clip);
if (G_UNLIKELY (clip_layer != (GESTimelineLayer *) layer)) {
GST_WARNING ("Clip doesn't belong to this layer");
if (clip_layer != NULL)
@ -429,7 +428,7 @@ ges_simple_timeline_layer_move_object (GESSimpleTimelineLayer * layer,
g_object_unref (clip_layer);
/* Find it's current position */
idx = g_list_index (priv->objects, object);
idx = g_list_index (priv->objects, clip);
if (G_UNLIKELY (idx == -1)) {
GST_WARNING ("Clip not controlled by this layer");
return FALSE;
@ -442,16 +441,15 @@ ges_simple_timeline_layer_move_object (GESSimpleTimelineLayer * layer,
return TRUE;
/* pop it off the list */
priv->objects = g_list_remove (priv->objects, object);
priv->objects = g_list_remove (priv->objects, clip);
/* re-add it at the proper position */
priv->objects = g_list_insert (priv->objects, object, newposition);
priv->objects = g_list_insert (priv->objects, clip, newposition);
/* recalculate positions */
gstl_recalculate (layer);
g_signal_emit (layer, gstl_signals[OBJECT_MOVED], 0, object, idx,
newposition);
g_signal_emit (layer, gstl_signals[OBJECT_MOVED], 0, clip, idx, newposition);
return TRUE;
}
@ -488,35 +486,35 @@ ges_simple_timeline_layer_is_valid (GESSimpleTimelineLayer * layer)
static void
ges_simple_timeline_layer_object_removed (GESTimelineLayer * layer,
GESClip * object)
GESClip * clip)
{
GESSimpleTimelineLayer *sl = (GESSimpleTimelineLayer *) layer;
/* remove object from our list */
sl->priv->objects = g_list_remove (sl->priv->objects, object);
/* remove clip from our list */
sl->priv->objects = g_list_remove (sl->priv->objects, clip);
gstl_recalculate (sl);
}
static void
ges_simple_timeline_layer_object_added (GESTimelineLayer * layer,
GESClip * object)
GESClip * clip)
{
GESSimpleTimelineLayer *sl = (GESSimpleTimelineLayer *) layer;
if (sl->priv->adding_object == FALSE) {
/* remove object from our list */
sl->priv->objects = g_list_append (sl->priv->objects, object);
/* remove clip from our list */
sl->priv->objects = g_list_append (sl->priv->objects, clip);
gstl_recalculate (sl);
}
g_signal_connect_swapped (object, "notify::duration",
g_signal_connect_swapped (clip, "notify::duration",
G_CALLBACK (gstl_recalculate), layer);
}
static void
clip_height_changed_cb (GESClip * object,
clip_height_changed_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, GESSimpleTimelineLayer * layer)
{
GST_LOG ("layer %p: notify height changed %p", layer, object);
GST_LOG ("layer %p: notify height changed %p", layer, clip);
gstl_recalculate (layer);
}

22
ges/ges-test-clip.c
View file

@ -57,7 +57,7 @@ enum
};
static GESTrackElement
* ges_test_clip_create_track_element (GESClip * obj, GESTrackType type);
* ges_test_clip_create_track_element (GESClip * clip, GESTrackType type);
static void
ges_test_clip_get_property (GObject * object, guint property_id,
@ -186,14 +186,14 @@ void
ges_test_clip_set_mute (GESTestClip * self, gboolean mute)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, mute:%d", self, mute);
self->priv->mute = mute;
/* Go over tracked objects, and update 'active' status on all audio objects */
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -218,11 +218,11 @@ void
ges_test_clip_set_vpattern (GESTestClip * self, GESVideoTestPattern vpattern)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
self->priv->vpattern = vpattern;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (GES_IS_VIDEO_TEST_SOURCE (trackelement))
@ -246,11 +246,11 @@ void
ges_test_clip_set_frequency (GESTestClip * self, gdouble freq)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
self->priv->freq = freq;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (GES_IS_AUDIO_TEST_SOURCE (trackelement))
@ -274,11 +274,11 @@ void
ges_test_clip_set_volume (GESTestClip * self, gdouble volume)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
self->priv->volume = volume;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (GES_IS_AUDIO_TEST_SOURCE (trackelement))
@ -347,9 +347,9 @@ ges_test_clip_get_volume (GESTestClip * self)
}
static GESTrackElement *
ges_test_clip_create_track_element (GESClip * obj, GESTrackType type)
ges_test_clip_create_track_element (GESClip * clip, GESTrackType type)
{
GESTestClipPrivate *priv = GES_TEST_CLIP (obj)->priv;
GESTestClipPrivate *priv = GES_TEST_CLIP (clip)->priv;
GESTrackElement *res = NULL;
GST_DEBUG ("Creating a GESTrackTestSource for type: %s",

34
ges/ges-text-overlay-clip.c
View file

@ -64,7 +64,7 @@ enum
};
static GESTrackElement
* ges_text_overlay_clip_create_track_element (GESClip * obj,
* ges_text_overlay_clip_create_track_element (GESClip * clip,
GESTrackType type);
static void
@ -267,7 +267,7 @@ void
ges_text_overlay_clip_set_text (GESTextOverlayClip * self, const gchar * text)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, text:%s", self, text);
@ -276,7 +276,7 @@ ges_text_overlay_clip_set_text (GESTextOverlayClip * self, const gchar * text)
self->priv->text = g_strdup (text);
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -303,7 +303,7 @@ ges_text_overlay_clip_set_font_desc (GESTextOverlayClip * self,
const gchar * font_desc)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, font_desc:%s", self, font_desc);
@ -312,7 +312,7 @@ ges_text_overlay_clip_set_font_desc (GESTextOverlayClip * self,
self->priv->font_desc = g_strdup (font_desc);
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -340,13 +340,13 @@ ges_text_overlay_clip_set_halign (GESTextOverlayClip * self,
GESTextHAlign halign)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, halign:%d", self, halign);
self->priv->halign = halign;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -374,13 +374,13 @@ ges_text_overlay_clip_set_valign (GESTextOverlayClip * self,
GESTextVAlign valign)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, valign:%d", self, valign);
self->priv->valign = valign;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -408,13 +408,13 @@ void
ges_text_overlay_clip_set_color (GESTextOverlayClip * self, guint32 color)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, color:%d", self, color);
self->priv->color = color;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -441,13 +441,13 @@ void
ges_text_overlay_clip_set_xpos (GESTextOverlayClip * self, gdouble position)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, xpos:%f", self, position);
self->priv->xpos = position;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -474,13 +474,13 @@ void
ges_text_overlay_clip_set_ypos (GESTextOverlayClip * self, gdouble position)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, ypos:%f", self, position);
self->priv->ypos = position;
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -603,10 +603,10 @@ ges_text_overlay_clip_get_ypos (GESTextOverlayClip * self)
}
static GESTrackElement *
ges_text_overlay_clip_create_track_element (GESClip * obj, GESTrackType type)
ges_text_overlay_clip_create_track_element (GESClip * clip, GESTrackType type)
{
GESTextOverlayClipPrivate *priv = GES_OVERLAY_TEXT_CLIP (obj)->priv;
GESTextOverlayClipPrivate *priv = GES_OVERLAY_TEXT_CLIP (clip)->priv;
GESTrackElement *res = NULL;
GST_DEBUG ("Creating a GESTrackOverlay");

4
ges/ges-text-overlay.c
View file

@ -140,12 +140,12 @@ ges_text_overlay_set_property (GObject * object,
}
static GstElement *
ges_text_overlay_create_element (GESTrackElement * object)
ges_text_overlay_create_element (GESTrackElement * track_element)
{
GstElement *ret, *text, *iconv, *oconv;
GstPad *src_target, *sink_target;
GstPad *src, *sink;
GESTextOverlay *self = GES_TEXT_OVERLAY (object);
GESTextOverlay *self = GES_TEXT_OVERLAY (track_element);
text = gst_element_factory_make ("textoverlay", NULL);
iconv = gst_element_factory_make ("videoconvert", NULL);

136
ges/ges-timeline-layer.c
View file

@ -46,7 +46,7 @@ G_DEFINE_TYPE_WITH_CODE (GESTimelineLayer, ges_timeline_layer,
struct _GESTimelineLayerPrivate
{
/*< private > */
GList *objects_start; /* The Clips sorted by start and
GList *clips_start; /* The Clips sorted by start and
* priority */
guint32 priority; /* The priority of the layer within the
@ -56,7 +56,7 @@ struct _GESTimelineLayerPrivate
typedef struct
{
GESClip *object;
GESClip *clip;
GESTimelineLayer *layer;
} NewAssetUData;
@ -123,9 +123,8 @@ ges_timeline_layer_dispose (GObject * object)
GST_DEBUG ("Disposing layer");
while (priv->objects_start)
ges_timeline_layer_remove_clip (layer,
(GESClip *) priv->objects_start->data);
while (priv->clips_start)
ges_timeline_layer_remove_clip (layer, (GESClip *) priv->clips_start->data);
G_OBJECT_CLASS (ges_timeline_layer_parent_class)->dispose (object);
}
@ -171,9 +170,9 @@ ges_timeline_layer_class_init (GESTimelineLayerClass * klass)
/**
* GESTimelineLayer::clip-added:
* @layer: the #GESTimelineLayer
* @object: the #GESClip that was added.
* @clip: the #GESClip that was added.
*
* Will be emitted after the object was added to the layer.
* Will be emitted after the clip was added to the layer.
*/
ges_timeline_layer_signals[OBJECT_ADDED] =
g_signal_new ("clip-added", G_TYPE_FROM_CLASS (klass),
@ -183,9 +182,9 @@ ges_timeline_layer_class_init (GESTimelineLayerClass * klass)
/**
* GESTimelineLayer::clip-removed:
* @layer: the #GESTimelineLayer
* @object: the #GESClip that was removed
* @clip: the #GESClip that was removed
*
* Will be emitted after the object was removed from the layer.
* Will be emitted after the clip was removed from the layer.
*/
ges_timeline_layer_signals[OBJECT_REMOVED] =
g_signal_new ("clip-removed", G_TYPE_FROM_CLASS (klass),
@ -217,7 +216,7 @@ static gboolean
ges_timeline_layer_resync_priorities (GESTimelineLayer * layer)
{
GList *tmp;
GESTimelineElement *obj;
GESTimelineElement *track_element;
GST_DEBUG ("Resync priorities of %p", layer);
@ -225,9 +224,9 @@ ges_timeline_layer_resync_priorities (GESTimelineLayer * layer)
* Ideally we want to do it from an even higher level, but here will
* do in the meantime. */
for (tmp = layer->priv->objects_start; tmp; tmp = tmp->next) {
obj = GES_TIMELINE_ELEMENT (tmp->data);
_set_priority0 (obj, _PRIORITY (obj));
for (tmp = layer->priv->clips_start; tmp; tmp = tmp->next) {
track_element = GES_TIMELINE_ELEMENT (tmp->data);
_set_priority0 (track_element, _PRIORITY (track_element));
}
return TRUE;
@ -241,7 +240,7 @@ new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata)
GESAsset *asset = ges_asset_request_finish (res, &error);
GST_DEBUG_OBJECT (udata->layer, "%" GST_PTR_FORMAT " Asset loaded, "
"setting its asset", udata->object);
"setting its asset", udata->clip);
if (error) {
GESProject *project = udata->layer->timeline ?
@ -266,10 +265,10 @@ new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata)
GESProject *project = udata->layer->timeline ?
GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE
(udata->layer->timeline))) : NULL;
ges_extractable_set_asset (GES_EXTRACTABLE (udata->object), asset);
ges_extractable_set_asset (GES_EXTRACTABLE (udata->clip), asset);
ges_project_add_asset (project, asset);
ges_timeline_layer_add_clip (udata->layer, udata->object);
ges_timeline_layer_add_clip (udata->layer, udata->clip);
}
g_object_unref (asset);
@ -280,27 +279,27 @@ new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata)
/**
* ges_timeline_layer_remove_clip:
* @layer: a #GESTimelineLayer
* @object: the #GESClip to remove
* @clip: the #GESClip to remove
*
* Removes the given @object from the @layer and unparents it.
* Unparenting it means the reference owned by @layer on the @object will be
* removed. If you wish to use the @object after this function, make sure you
* Removes the given @clip from the @layer and unparents it.
* Unparenting it means the reference owned by @layer on the @clip will be
* removed. If you wish to use the @clip after this function, make sure you
* call g_object_ref() before removing it from the @layer.
*
* Returns: TRUE if the object could be removed, FALSE if the layer does
* not want to remove the object.
* Returns: TRUE if the clip could be removed, FALSE if the layer does
* not want to remove the clip.
*/
gboolean
ges_timeline_layer_remove_clip (GESTimelineLayer * layer, GESClip * object)
ges_timeline_layer_remove_clip (GESTimelineLayer * layer, GESClip * clip)
{
GESTimelineLayer *current_layer;
g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), FALSE);
g_return_val_if_fail (GES_IS_CLIP (object), FALSE);
g_return_val_if_fail (GES_IS_CLIP (clip), FALSE);
GST_DEBUG ("layer:%p, object:%p", layer, object);
GST_DEBUG ("layer:%p, clip:%p", layer, clip);
current_layer = ges_clip_get_layer (object);
current_layer = ges_clip_get_layer (clip);
if (G_UNLIKELY (current_layer != layer)) {
GST_WARNING ("Clip doesn't belong to this layer");
@ -312,17 +311,16 @@ ges_timeline_layer_remove_clip (GESTimelineLayer * layer, GESClip * object)
g_object_unref (current_layer);
/* emit 'clip-removed' */
g_signal_emit (layer, ges_timeline_layer_signals[OBJECT_REMOVED], 0, object);
g_signal_emit (layer, ges_timeline_layer_signals[OBJECT_REMOVED], 0, clip);
/* inform the object it's no longer in a layer */
ges_clip_set_layer (object, NULL);
/* inform the clip it's no longer in a layer */
ges_clip_set_layer (clip, NULL);
/* Remove it from our list of controlled objects */
layer->priv->objects_start =
g_list_remove (layer->priv->objects_start, object);
layer->priv->clips_start = g_list_remove (layer->priv->clips_start, clip);
/* Remove our reference to the object */
g_object_unref (object);
/* Remove our reference to the clip */
g_object_unref (clip);
return TRUE;
}
@ -427,7 +425,7 @@ ges_timeline_layer_get_clips (GESTimelineLayer * layer)
return klass->get_objects (layer);
}
return g_list_sort (g_list_copy_deep (layer->priv->objects_start,
return g_list_sort (g_list_copy_deep (layer->priv->clips_start,
(GCopyFunc) gst_object_ref, NULL),
(GCompareFunc) element_start_compare);
}
@ -436,7 +434,7 @@ ges_timeline_layer_get_clips (GESTimelineLayer * layer)
* ges_timeline_layer_is_empty:
* @layer: The #GESTimelineLayer to check
*
* Convenience method to check if @layer is empty (doesn't contain any object),
* Convenience method to check if @layer is empty (doesn't contain any clip),
* or not.
*
* Returns: %TRUE if @layer is empty, %FALSE if it already contains at least
@ -447,29 +445,29 @@ ges_timeline_layer_is_empty (GESTimelineLayer * layer)
{
g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), FALSE);
return (layer->priv->objects_start == NULL);
return (layer->priv->clips_start == NULL);
}
/**
* ges_timeline_layer_add_clip:
* @layer: a #GESTimelineLayer
* @object: (transfer full): the #GESClip to add.
* @clip: (transfer full): the #GESClip to add.
*
* Adds the given object to the layer. Sets the object's parent, and thus
* takes ownership of the object.
* Adds the given clip to the layer. Sets the clip's parent, and thus
* takes ownership of the clip.
*
* An object can only be added to one layer.
* An clip can only be added to one layer.
*
* Calling this method will construct and properly set all the media related
* elements on @object. If you need to know when those objects (actually #GESTrackElement)
* are constructed, you should connect to the object::track-element-added signal which
* elements on @clip. If you need to know when those objects (actually #GESTrackElement)
* are constructed, you should connect to the clip::track-element-added signal which
* is emited right after those elements are ready to be used.
*
* Returns: TRUE if the object was properly added to the layer, or FALSE
* if the @layer refuses to add the object.
* Returns: TRUE if the clip was properly added to the layer, or FALSE
* if the @layer refuses to add the clip.
*/
gboolean
ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * object)
ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * clip)
{
GESAsset *asset;
GESTimelineLayerPrivate *priv;
@ -477,42 +475,42 @@ ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * object)
guint32 maxprio, minprio, prio;
g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), FALSE);
g_return_val_if_fail (GES_IS_CLIP (object), FALSE);
g_return_val_if_fail (GES_IS_CLIP (clip), FALSE);
GST_DEBUG_OBJECT (layer, "adding object:%p", object);
GST_DEBUG_OBJECT (layer, "adding clip:%p", clip);
priv = layer->priv;
current_layer = ges_clip_get_layer (object);
current_layer = ges_clip_get_layer (clip);
if (G_UNLIKELY (current_layer)) {
GST_WARNING ("Clip %p already belongs to another layer", object);
GST_WARNING ("Clip %p already belongs to another layer", clip);
g_object_unref (current_layer);
return FALSE;
}
asset = ges_extractable_get_asset (GES_EXTRACTABLE (object));
asset = ges_extractable_get_asset (GES_EXTRACTABLE (clip));
if (asset == NULL) {
gchar *id;
NewAssetUData *mudata = g_slice_new (NewAssetUData);
mudata->object = object;
mudata->clip = clip;
mudata->layer = layer;
GST_DEBUG_OBJECT (layer, "%" GST_PTR_FORMAT " as no reference to any "
"assets creating a asset... trying sync", object);
"assets creating a asset... trying sync", clip);
id = ges_extractable_get_id (GES_EXTRACTABLE (object));
asset = ges_asset_request (G_OBJECT_TYPE (object), id, NULL);
id = ges_extractable_get_id (GES_EXTRACTABLE (clip));
asset = ges_asset_request (G_OBJECT_TYPE (clip), id, NULL);
if (asset == NULL) {
GESProject *project = layer->timeline ?
GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE
(layer->timeline))) : NULL;
ges_asset_request_async (G_OBJECT_TYPE (object),
ges_asset_request_async (G_OBJECT_TYPE (clip),
id, NULL, (GAsyncReadyCallback) new_asset_cb, mudata);
if (project)
ges_project_add_loading_asset (project, G_OBJECT_TYPE (object), id);
ges_project_add_loading_asset (project, G_OBJECT_TYPE (clip), id);
g_free (id);
GST_LOG_OBJECT (layer, "Object added async");
@ -520,43 +518,43 @@ ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * object)
}
g_free (id);
ges_extractable_set_asset (GES_EXTRACTABLE (object), asset);
ges_extractable_set_asset (GES_EXTRACTABLE (clip), asset);
g_slice_free (NewAssetUData, mudata);
}
g_object_ref_sink (object);
g_object_ref_sink (clip);
/* Take a reference to the object and store it stored by start/priority */
priv->objects_start = g_list_insert_sorted (priv->objects_start, object,
/* Take a reference to the clip and store it stored by start/priority */
priv->clips_start = g_list_insert_sorted (priv->clips_start, clip,
(GCompareFunc) element_start_compare);
/* Inform the object it's now in this layer */
ges_clip_set_layer (object, layer);
/* Inform the clip it's now in this layer */
ges_clip_set_layer (clip, layer);
GST_DEBUG ("current object priority : %d, layer min/max : %d/%d",
_PRIORITY (object), layer->min_gnl_priority, layer->max_gnl_priority);
GST_DEBUG ("current clip priority : %d, layer min/max : %d/%d",
_PRIORITY (clip), layer->min_gnl_priority, layer->max_gnl_priority);
/* Set the priority. */
maxprio = layer->max_gnl_priority;
minprio = layer->min_gnl_priority;
prio = _PRIORITY (object);
prio = _PRIORITY (clip);
if (minprio + prio > (maxprio)) {
GST_WARNING_OBJECT (layer,
"%p is out of the layer space, setting its priority to "
"%d, setting it to the maximum priority of the layer: %d", object, prio,
"%d, setting it to the maximum priority of the layer: %d", clip, prio,
maxprio - minprio);
_set_priority0 (GES_TIMELINE_ELEMENT (object), LAYER_HEIGHT - 1);
_set_priority0 (GES_TIMELINE_ELEMENT (clip), LAYER_HEIGHT - 1);
}
/* If the object has an acceptable priority, we just let it with its current
/* If the clip has an acceptable priority, we just let it with its current
* priority */
ges_timeline_layer_resync_priorities (layer);
/* emit 'clip-added' */
g_signal_emit (layer, ges_timeline_layer_signals[OBJECT_ADDED], 0, object);
g_signal_emit (layer, ges_timeline_layer_signals[OBJECT_ADDED], 0, clip);
return TRUE;
}

97
ges/ges-timeline.c
View file

@ -89,7 +89,7 @@ _destroy_obj_iters (TrackObjIters * iters)
*/
struct _MoveContext
{
GESClip *obj;
GESClip *clip;
GESEdge edge;
GESEditMode mode;
@ -1238,7 +1238,7 @@ ges_timeline_set_moving_context (GESTimeline * timeline, GESTrackElement * obj,
GESClip *clip = ges_track_element_get_clip (obj);
/* Still in the same mv_ctx */
if ((mv_ctx->obj == clip && mv_ctx->mode == mode &&
if ((mv_ctx->clip == clip && mv_ctx->mode == mode &&
mv_ctx->edge == edge && !mv_ctx->needs_move_ctx)) {
GST_DEBUG ("Keeping the same moving mv_ctx");
@ -1247,13 +1247,13 @@ ges_timeline_set_moving_context (GESTimeline * timeline, GESTrackElement * obj,
GST_DEBUG_OBJECT (clip,
"Changing context:\nold: obj: %p, mode: %d, edge: %d \n"
"new: obj: %p, mode: %d, edge: %d ! Has changed %i", mv_ctx->obj,
"new: obj: %p, mode: %d, edge: %d ! Has changed %i", mv_ctx->clip,
mv_ctx->mode, mv_ctx->edge, clip, mode, edge, mv_ctx->needs_move_ctx);
clean_movecontext (mv_ctx);
mv_ctx->edge = edge;
mv_ctx->mode = mode;
mv_ctx->obj = clip;
mv_ctx->clip = clip;
mv_ctx->needs_move_ctx = FALSE;
/* We try to find a Source inside the Clip so we can set the
@ -1729,18 +1729,18 @@ timeline_context_to_layer (GESTimeline * timeline, gint offset)
}
static void
add_object_to_track (GESClip * object, GESTrackElement * track_element,
add_object_to_track (GESClip * clip, GESTrackElement * track_element,
GESTrack * track)
{
if (!ges_clip_add_track_element (object, track_element)) {
GST_WARNING_OBJECT (object, "Failed to add track element to clip");
if (!ges_clip_add_track_element (clip, track_element)) {
GST_WARNING_OBJECT (clip, "Failed to add track element to clip");
gst_object_unref (track_element);
return;
}
if (!ges_track_add_element (track, track_element)) {
GST_WARNING_OBJECT (object, "Failed to add track element to track");
ges_clip_release_track_element (object, track_element);
GST_WARNING_OBJECT (clip, "Failed to add track element to track");
ges_clip_release_track_element (clip, track_element);
gst_object_unref (track_element);
return;
}
@ -1768,8 +1768,7 @@ select_tracks_for_object_default (GESTimeline * timeline,
}
static void
add_object_to_tracks (GESTimeline * timeline, GESClip * object,
GESTrack * track)
add_object_to_tracks (GESTimeline * timeline, GESClip * clip, GESTrack * track)
{
gint i;
GPtrArray *tracks = NULL;
@ -1777,9 +1776,9 @@ add_object_to_tracks (GESTimeline * timeline, GESClip * object,
GList *tmp, *l, *track_elements;
GST_DEBUG_OBJECT (timeline, "Creating %" GST_PTR_FORMAT
" trackelements and adding them to our tracks", object);
" trackelements and adding them to our tracks", clip);
types = ges_clip_get_supported_formats (object);
types = ges_clip_get_supported_formats (clip);
if (track) {
if ((types & track->type) == 0)
return;
@ -1792,7 +1791,7 @@ add_object_to_tracks (GESTimeline * timeline, GESClip * object,
if (((track->type & types) == 0 || (track->type & visited_type)))
continue;
track_elements = ges_clip_create_track_elements (object, track->type);
track_elements = ges_clip_create_track_elements (clip, track->type);
for (l = track_elements; l; l = l->next) {
GESTrack *tmp_track;
GESTrackElement *track_element = l->data;
@ -1801,7 +1800,7 @@ add_object_to_tracks (GESTimeline * timeline, GESClip * object,
"Asking to which track it should be added", track_element);
g_signal_emit (G_OBJECT (timeline),
ges_timeline_signals[SELECT_TRACKS_FOR_OBJECT], 0, object,
ges_timeline_signals[SELECT_TRACKS_FOR_OBJECT], 0, clip,
track_element, &tracks);
if (!tracks || tracks->len == 0) {
@ -1828,7 +1827,7 @@ add_object_to_tracks (GESTimeline * timeline, GESClip * object,
GST_LOG_OBJECT (timeline, "Trying to add %p to track %p",
track_element_copy, tmp_track);
add_object_to_track (object, track_element_copy, tmp_track);
add_object_to_track (clip, track_element_copy, tmp_track);
gst_object_unref (tmp_track);
}
@ -1853,12 +1852,12 @@ layer_auto_transition_changed_cb (GESTimelineLayer * layer,
}
static void
layer_object_added_cb (GESTimelineLayer * layer, GESClip * object,
layer_object_added_cb (GESTimelineLayer * layer, GESClip * clip,
GESTimeline * timeline)
{
if (ges_clip_is_moving_from_layer (object)) {
if (ges_clip_is_moving_from_layer (clip)) {
GST_DEBUG ("Clip %p is moving from a layer to another, not doing"
" anything on it", object);
" anything on it", clip);
timeline->priv->movecontext.needs_move_ctx = TRUE;
_create_transitions_on_layer (timeline, layer, NULL, NULL,
@ -1867,8 +1866,8 @@ layer_object_added_cb (GESTimelineLayer * layer, GESClip * object,
return;
}
GST_DEBUG ("New Clip %p added to layer %p", object, layer);
add_object_to_tracks (timeline, object, NULL);
GST_DEBUG ("New Clip %p added to layer %p", clip, layer);
add_object_to_tracks (timeline, clip, NULL);
GST_DEBUG ("Done");
}
@ -1881,37 +1880,39 @@ layer_priority_changed_cb (GESTimelineLayer * layer,
}
static void
layer_object_removed_cb (GESTimelineLayer * layer, GESClip * object,
layer_object_removed_cb (GESTimelineLayer * layer, GESClip * clip,
GESTimeline * timeline)
{
GList *trackelements, *tmp;
if (ges_clip_is_moving_from_layer (object)) {
if (ges_clip_is_moving_from_layer (clip)) {
GST_DEBUG ("Clip %p is moving from a layer to another, not doing"
" anything on it", object);
" anything on it", clip);
return;
}
GST_DEBUG ("Clip %p removed from layer %p", object, layer);
GST_DEBUG ("Clip %p removed from layer %p", clip, layer);
/* Go over the object's track element and figure out which one belongs to
/* Go over the clip's track element and figure out which one belongs to
* the list of tracks we control */
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trobj = (GESTrackElement *) tmp->data;
GESTrackElement *track_element = (GESTrackElement *) tmp->data;
GST_DEBUG_OBJECT (timeline, "Trying to remove TrackElement %p", trobj);
GST_DEBUG_OBJECT (timeline, "Trying to remove TrackElement %p",
track_element);
if (G_LIKELY (g_list_find_custom (timeline->priv->priv_tracks,
ges_track_element_get_track (trobj),
ges_track_element_get_track (track_element),
(GCompareFunc) custom_find_track))) {
GST_DEBUG ("Belongs to one of the tracks we control");
ges_track_remove_element (ges_track_element_get_track (trobj), trobj);
ges_clip_release_track_element (object, trobj);
ges_track_remove_element (ges_track_element_get_track (track_element),
track_element);
ges_clip_release_track_element (clip, track_element);
}
/* removing the reference added by _get_track_elements() */
g_object_unref (trobj);
g_object_unref (track_element);
}
g_list_free (trackelements);
@ -2012,39 +2013,39 @@ trackelement_duration_changed_cb (GESTrackElement * child,
}
static void
track_element_added_cb (GESTrack * track, GESTrackElement * object,
track_element_added_cb (GESTrack * track, GESTrackElement * track_element,
GESTimeline * timeline)
{
/* Auto transition should be updated before we receive the signal */
g_signal_connect_after (GES_TRACK_ELEMENT (object), "notify::start",
g_signal_connect_after (GES_TRACK_ELEMENT (track_element), "notify::start",
G_CALLBACK (trackelement_start_changed_cb), timeline);
g_signal_connect_after (GES_TRACK_ELEMENT (object), "notify::duration",
g_signal_connect_after (GES_TRACK_ELEMENT (track_element), "notify::duration",
G_CALLBACK (trackelement_duration_changed_cb), timeline);
g_signal_connect_after (GES_TRACK_ELEMENT (object), "notify::priority",
g_signal_connect_after (GES_TRACK_ELEMENT (track_element), "notify::priority",
G_CALLBACK (trackelement_priority_changed_cb), timeline);
start_tracking_track_element (timeline, object);
start_tracking_track_element (timeline, track_element);
}
static void
track_element_removed_cb (GESTrack * track, GESTrackElement * object,
track_element_removed_cb (GESTrack * track, GESTrackElement * track_element,
GESTimeline * timeline)
{
if (GES_IS_SOURCE (object)) {
if (GES_IS_SOURCE (track_element)) {
/* Make sure to reinitialise the moving context next time */
timeline->priv->movecontext.needs_move_ctx = TRUE;
}
/* Disconnect all signal handlers */
g_signal_handlers_disconnect_by_func (object, trackelement_start_changed_cb,
NULL);
g_signal_handlers_disconnect_by_func (object,
g_signal_handlers_disconnect_by_func (track_element,
trackelement_start_changed_cb, NULL);
g_signal_handlers_disconnect_by_func (track_element,
trackelement_duration_changed_cb, NULL);
g_signal_handlers_disconnect_by_func (object,
g_signal_handlers_disconnect_by_func (track_element,
trackelement_priority_changed_cb, NULL);
stop_tracking_track_element (timeline, object);
stop_tracking_track_element (timeline, track_element);
}
static void
@ -2432,10 +2433,10 @@ ges_timeline_add_track (GESTimeline * timeline, GESTrack * track)
objects = ges_timeline_layer_get_clips (tmp->data);
for (obj = objects; obj; obj = obj->next) {
GESClip *object = obj->data;
GESClip *clip = obj->data;
add_object_to_tracks (timeline, object, track);
g_object_unref (object);
add_object_to_tracks (timeline, clip, track);
g_object_unref (clip);
}
g_list_free (objects);
}

26
ges/ges-title-clip.c
View file

@ -67,12 +67,12 @@ enum
};
static GESTrackElement
* ges_title_clip_create_track_element (GESClip * obj, GESTrackType type);
* ges_title_clip_create_track_element (GESClip * clip, GESTrackType type);
static void
ges_title_clip_track_element_added (GESClip * obj,
ges_title_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement);
static void ges_title_clip_track_element_released (GESClip * obj,
static void ges_title_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement);
static void
@ -593,44 +593,44 @@ ges_title_clip_get_ypos (GESTitleClip * self)
}
static void
ges_title_clip_track_element_released (GESClip * obj,
ges_title_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement)
{
GESTitleClipPrivate *priv = GES_TITLE_CLIP (obj)->priv;
GESTitleClipPrivate *priv = GES_TITLE_CLIP (clip)->priv;
/* If this is called, we should be sure the trackelement exists */
if (GES_IS_TITLE_SOURCE (trackelement)) {
GST_DEBUG_OBJECT (obj, "%p released from %p", trackelement, obj);
GST_DEBUG_OBJECT (clip, "%p released from %p", trackelement, clip);
priv->track_titles = g_slist_remove (priv->track_titles, trackelement);
g_object_unref (trackelement);
}
}
static void
ges_title_clip_track_element_added (GESClip * obj,
ges_title_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement)
{
GESTitleClipPrivate *priv = GES_TITLE_CLIP (obj)->priv;
GESTitleClipPrivate *priv = GES_TITLE_CLIP (clip)->priv;
if (GES_IS_TITLE_SOURCE (trackelement)) {
GST_DEBUG_OBJECT (obj, "%p added to %p", trackelement, obj);
GST_DEBUG_OBJECT (clip, "%p added to %p", trackelement, clip);
priv->track_titles =
g_slist_prepend (priv->track_titles, g_object_ref (trackelement));
}
}
static GESTrackElement *
ges_title_clip_create_track_element (GESClip * obj, GESTrackType type)
ges_title_clip_create_track_element (GESClip * clip, GESTrackType type)
{
GESTitleClipPrivate *priv = GES_TITLE_CLIP (obj)->priv;
GESTitleClipPrivate *priv = GES_TITLE_CLIP (clip)->priv;
GESTrackElement *res = NULL;
GST_DEBUG_OBJECT (obj, "a GESTitleSource");
GST_DEBUG_OBJECT (clip, "a GESTitleSource");
if (type == GES_TRACK_TYPE_VIDEO) {
res = (GESTrackElement *) ges_title_source_new ();
GST_DEBUG_OBJECT (obj, "text property");
GST_DEBUG_OBJECT (clip, "text property");
ges_title_source_set_text ((GESTitleSource *) res, priv->text);
ges_title_source_set_font_desc ((GESTitleSource *) res, priv->font_desc);
ges_title_source_set_halignment ((GESTitleSource *) res, priv->halign);

95
ges/ges-track-element.c
View file

@ -92,24 +92,24 @@ static GstElement *ges_track_element_create_gnl_object_func (GESTrackElement *
object);
static void gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg
G_GNUC_UNUSED, GESTrackElement * obj);
G_GNUC_UNUSED, GESTrackElement * track_element);
static void gnlobject_media_start_cb (GstElement * gnlobject, GParamSpec * arg
G_GNUC_UNUSED, GESTrackElement * obj);
G_GNUC_UNUSED, GESTrackElement * track_element);
static void gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg
G_GNUC_UNUSED, GESTrackElement * obj);
G_GNUC_UNUSED, GESTrackElement * track_element);
static void gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg
G_GNUC_UNUSED, GESTrackElement * obj);
G_GNUC_UNUSED, GESTrackElement * track_element);
static void gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg
G_GNUC_UNUSED, GESTrackElement * obj);
G_GNUC_UNUSED, GESTrackElement * track_element);
static void connect_properties_signals (GESTrackElement * object);
static void connect_signal (gpointer key, gpointer value, gpointer user_data);
static void gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg
G_GNUC_UNUSED, GESTrackElement * obj);
G_GNUC_UNUSED, GESTrackElement * track_element);
static gboolean _set_start (GESTimelineElement * element, GstClockTime start);
static gboolean _set_inpoint (GESTimelineElement * element,
@ -131,20 +131,20 @@ static void
ges_track_element_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec)
{
GESTrackElement *tobj = GES_TRACK_ELEMENT (object);
GESTrackElement *track_element = GES_TRACK_ELEMENT (object);
switch (property_id) {
case PROP_ACTIVE:
g_value_set_boolean (value, ges_track_element_is_active (tobj));
g_value_set_boolean (value, ges_track_element_is_active (track_element));
break;
case PROP_LOCKED:
g_value_set_boolean (value, ges_track_element_is_locked (tobj));
g_value_set_boolean (value, ges_track_element_is_locked (track_element));
break;
case PROP_TRACK_TYPE:
g_value_set_flags (value, tobj->priv->track_type);
g_value_set_flags (value, track_element->priv->track_type);
break;
case PROP_TRACK:
g_value_set_object (value, tobj->priv->track);
g_value_set_object (value, track_element->priv->track);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@ -155,17 +155,18 @@ static void
ges_track_element_set_property (GObject * object, guint property_id,
const GValue * value, GParamSpec * pspec)
{
GESTrackElement *tobj = GES_TRACK_ELEMENT (object);
GESTrackElement *track_element = GES_TRACK_ELEMENT (object);
switch (property_id) {
case PROP_ACTIVE:
ges_track_element_set_active (tobj, g_value_get_boolean (value));
ges_track_element_set_active (track_element, g_value_get_boolean (value));
break;
case PROP_LOCKED:
ges_track_element_set_locked_internal (tobj, g_value_get_boolean (value));
ges_track_element_set_locked_internal (track_element,
g_value_get_boolean (value));
break;
case PROP_TRACK_TYPE:
tobj->priv->track_type = g_value_get_flags (value);
track_element->priv->track_type = g_value_get_flags (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@ -433,26 +434,27 @@ ges_track_element_get_track_type (GESTrackElement * object)
/* Callbacks from the GNonLin object */
static void
gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj)
GESTrackElement * track_element)
{
guint64 start;
g_object_get (gnlobject, "start", &start, NULL);
GST_DEBUG ("gnlobject start : %" GST_TIME_FORMAT " current : %"
GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (_START (obj)));
GST_TIME_FORMAT, GST_TIME_ARGS (start),
GST_TIME_ARGS (_START (track_element)));
if (start != _START (obj)) {
_START (obj) = start;
g_object_notify (G_OBJECT (obj), "start");
if (start != _START (track_element)) {
_START (track_element) = start;
g_object_notify (G_OBJECT (track_element), "start");
}
}
static void
gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg
G_GNUC_UNUSED, GESTrackElement * obj)
G_GNUC_UNUSED, GESTrackElement * track_element)
{
g_signal_emit (obj, ges_track_element_signals[DEEP_NOTIFY], 0,
g_signal_emit (track_element, ges_track_element_signals[DEEP_NOTIFY], 0,
GST_ELEMENT (element), arg);
}
@ -484,77 +486,80 @@ connect_properties_signals (GESTrackElement * object)
/* Callbacks from the GNonLin object */
static void
gnlobject_media_start_cb (GstElement * gnlobject,
GParamSpec * arg G_GNUC_UNUSED, GESTrackElement * obj)
GParamSpec * arg G_GNUC_UNUSED, GESTrackElement * track_element)
{
guint64 inpoint;
g_object_get (gnlobject, "media-start", &inpoint, NULL);
GST_DEBUG ("gnlobject in-point : %" GST_TIME_FORMAT " current : %"
GST_TIME_FORMAT, GST_TIME_ARGS (inpoint), GST_TIME_ARGS (_INPOINT (obj)));
GST_TIME_FORMAT, GST_TIME_ARGS (inpoint),
GST_TIME_ARGS (_INPOINT (track_element)));
if (inpoint != _INPOINT (obj)) {
_INPOINT (obj) = inpoint;
g_object_notify (G_OBJECT (obj), "in-point");
if (inpoint != _INPOINT (track_element)) {
_INPOINT (track_element) = inpoint;
g_object_notify (G_OBJECT (track_element), "in-point");
}
}
static void
gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj)
GESTrackElement * track_element)
{
guint32 priority;
g_object_get (gnlobject, "priority", &priority, NULL);
GST_DEBUG ("gnlobject priority : %d current : %d", priority, _PRIORITY (obj));
GST_DEBUG ("gnlobject priority : %d current : %d", priority,
_PRIORITY (track_element));
if (priority != _PRIORITY (obj)) {
_PRIORITY (obj) = priority;
g_object_notify (G_OBJECT (obj), "priority");
if (priority != _PRIORITY (track_element)) {
_PRIORITY (track_element) = priority;
g_object_notify (G_OBJECT (track_element), "priority");
}
}
static void
gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj)
GESTrackElement * track_element)
{
guint64 duration;
GESTrackElementClass *klass;
klass = GES_TRACK_ELEMENT_GET_CLASS (obj);
klass = GES_TRACK_ELEMENT_GET_CLASS (track_element);
g_object_get (gnlobject, "duration", &duration, NULL);
GST_DEBUG_OBJECT (gnlobject, "duration : %" GST_TIME_FORMAT " current : %"
GST_TIME_FORMAT, GST_TIME_ARGS (duration),
GST_TIME_ARGS (_DURATION (obj)));
GST_TIME_ARGS (_DURATION (track_element)));
if (duration != _DURATION (obj)) {
_DURATION (obj) = duration;
if (duration != _DURATION (track_element)) {
_DURATION (track_element) = duration;
if (klass->duration_changed)
klass->duration_changed (obj, duration);
g_object_notify (G_OBJECT (obj), "duration");
klass->duration_changed (track_element, duration);
g_object_notify (G_OBJECT (track_element), "duration");
}
}
static void
gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj)
GESTrackElement * track_element)
{
gboolean active;
GESTrackElementClass *klass;
klass = GES_TRACK_ELEMENT_GET_CLASS (obj);
klass = GES_TRACK_ELEMENT_GET_CLASS (track_element);
g_object_get (gnlobject, "active", &active, NULL);
GST_DEBUG ("gnlobject active : %d current : %d", active, obj->active);
GST_DEBUG ("gnlobject active : %d current : %d", active,
track_element->active);
if (active != obj->active) {
obj->active = active;
if (active != track_element->active) {
track_element->active = active;
if (klass->active_changed)
klass->active_changed (obj, active);
klass->active_changed (track_element, active);
}
}

22
ges/ges-transition-clip.c
View file

@ -59,9 +59,9 @@ enum
static GESTrackElement *_create_track_element (GESClip
* self, GESTrackType type);
static void
ges_transition_clip_track_element_added (GESClip * obj,
ges_transition_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement);
static void ges_transition_clip_track_element_released (GESClip * obj,
static void ges_transition_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement);
/* Internal methods */
@ -268,14 +268,14 @@ ges_transition_clip_init (GESTransitionClip * self)
}
static void
ges_transition_clip_track_element_released (GESClip * obj,
ges_transition_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement)
{
GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (obj)->priv;
GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (clip)->priv;
/* If this is called, we should be sure the trackelement exists */
if (GES_IS_VIDEO_TRANSITION (trackelement)) {
GST_DEBUG ("GESVideoTransition %p released from %p", trackelement, obj);
GST_DEBUG ("GESVideoTransition %p released from %p", trackelement, clip);
priv->video_transitions =
g_slist_remove (priv->video_transitions, trackelement);
g_object_unref (trackelement);
@ -283,28 +283,28 @@ ges_transition_clip_track_element_released (GESClip * obj,
}
static void
ges_transition_clip_track_element_added (GESClip * obj,
ges_transition_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement)
{
GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (obj)->priv;
GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (clip)->priv;
if (GES_IS_VIDEO_TRANSITION (trackelement)) {
GST_DEBUG ("GESVideoTransition %p added to %p", trackelement, obj);
GST_DEBUG ("GESVideoTransition %p added to %p", trackelement, clip);
priv->video_transitions =
g_slist_prepend (priv->video_transitions, g_object_ref (trackelement));
}
}
static GESTrackElement *
_create_track_element (GESClip * obj, GESTrackType type)
_create_track_element (GESClip * clip, GESTrackType type)
{
GESTransitionClip *transition = (GESTransitionClip *) obj;
GESTransitionClip *transition = (GESTransitionClip *) clip;
GESTrackElement *res = NULL;
GESTrackType supportedformats;
GST_DEBUG ("Creating a GESTransition");
supportedformats = ges_clip_get_supported_formats (obj);
supportedformats = ges_clip_get_supported_formats (clip);
if (type == GES_TRACK_TYPE_VIDEO) {
if (supportedformats == GES_TRACK_TYPE_UNKNOWN ||
supportedformats & GES_TRACK_TYPE_VIDEO) {

18
ges/ges-uri-clip.c
View file

@ -66,9 +66,9 @@ enum
static GList *ges_uri_clip_create_track_elements (GESClip *
obj, GESTrackType type);
clip, GESTrackType type);
static GESTrackElement
* ges_uri_clip_create_track_element (GESClip * obj, GESTrackType type);
* ges_uri_clip_create_track_element (GESClip * clip, GESTrackType type);
void ges_uri_clip_set_uri (GESUriClip * self, gchar * uri);
gboolean
@ -281,14 +281,14 @@ void
ges_uri_clip_set_mute (GESUriClip * self, gboolean mute)
{
GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, mute:%d", self, mute);
self->priv->mute = mute;
/* Go over tracked objects, and update 'active' status on all audio objects */
trackelements = ges_clip_get_track_elements (object);
trackelements = ges_clip_get_track_elements (clip);
for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -370,16 +370,16 @@ ges_uri_clip_get_uri (GESUriClip * self)
}
static GList *
ges_uri_clip_create_track_elements (GESClip * obj, GESTrackType type)
ges_uri_clip_create_track_elements (GESClip * clip, GESTrackType type)
{
GList *res = NULL;
const GList *tmp, *stream_assets;
g_return_val_if_fail (GES_TIMELINE_ELEMENT (obj)->asset, NULL);
g_return_val_if_fail (GES_TIMELINE_ELEMENT (clip)->asset, NULL);
stream_assets =
ges_uri_clip_asset_get_stream_assets (GES_URI_CLIP_ASSET
(GES_TIMELINE_ELEMENT (obj)->asset));
(GES_TIMELINE_ELEMENT (clip)->asset));
for (tmp = stream_assets; tmp; tmp = tmp->next) {
GESTrackElementAsset *asset = GES_TRACK_ELEMENT_ASSET (tmp->data);
@ -391,9 +391,9 @@ ges_uri_clip_create_track_elements (GESClip * obj, GESTrackType type)
}
static GESTrackElement *
ges_uri_clip_create_track_element (GESClip * obj, GESTrackType type)
ges_uri_clip_create_track_element (GESClip * clip, GESTrackType type)
{
GESUriClipPrivate *priv = GES_URI_CLIP (obj)->priv;
GESUriClipPrivate *priv = GES_URI_CLIP (clip)->priv;
GESTrackElement *res;
if (priv->is_image) {

4
ges/ges-uri-source.c
View file

@ -118,12 +118,12 @@ ges_track_filesource_dispose (GObject * object)
}
static GstElement *
ges_track_filesource_create_gnl_object (GESTrackElement * object)
ges_track_filesource_create_gnl_object (GESTrackElement * track_element)
{
GstElement *gnlobject;
gnlobject = gst_element_factory_make ("gnlurisource", NULL);
g_object_set (gnlobject, "uri", ((GESUriSource *) object)->uri, NULL);
g_object_set (gnlobject, "uri", ((GESUriSource *) track_element)->uri, NULL);
return gnlobject;
}

10
tests/benchmarks/timeline.c
View file

@ -30,7 +30,7 @@ main (gint argc, gchar * argv[])
GESAsset *asset;
GESTimeline *timeline;
GESTimelineLayer *layer;
GESClip *object;
GESClip *clip;
GstClockTime start, start_ripple, end, end_ripple, max_rippling_time = 0,
min_rippling_time = GST_CLOCK_TIME_NONE;
@ -43,20 +43,20 @@ main (gint argc, gchar * argv[])
ges_timeline_add_layer (timeline, layer);
start = gst_util_get_timestamp ();
object = GES_CLIP (ges_timeline_layer_add_asset (layer, asset, 0,
clip = GES_CLIP (ges_timeline_layer_add_asset (layer, asset, 0,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
for (i = 1; i < NUM_OBJECTS; i++)
ges_timeline_layer_add_asset (layer, asset, i * 1000, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN);
end = gst_util_get_timestamp ();
g_print ("%" GST_TIME_FORMAT " - adding %d object to the timeline\n",
g_print ("%" GST_TIME_FORMAT " - adding %d clip to the timeline\n",
GST_TIME_ARGS (end - start), i);
start_ripple = gst_util_get_timestamp ();
for (i = 1; i < 501; i++) {
start = gst_util_get_timestamp ();
ges_clip_edit (object, NULL, 0, GES_EDIT_MODE_NORMAL,
ges_clip_edit (clip, NULL, 0, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, i * 1000);
end = gst_util_get_timestamp ();
max_rippling_time = MAX (max_rippling_time, end - start);
@ -75,7 +75,7 @@ main (gint argc, gchar * argv[])
start_ripple = gst_util_get_timestamp ();
for (i = 1; i < 501; i++) {
start = gst_util_get_timestamp ();
ges_clip_edit (object, NULL, 0, GES_EDIT_MODE_NORMAL,
ges_clip_edit (clip, NULL, 0, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, i * 1000);
end = gst_util_get_timestamp ();
max_rippling_time = MAX (max_rippling_time, end - start);

102
tests/check/ges/backgroundsource.c
View file

@ -39,26 +39,26 @@ GST_START_TEST (test_test_source_properties)
{
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
track = ges_track_new (GES_TRACK_TYPE_AUDIO, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL);
object = (GESClip *)
clip = (GESClip *)
ges_test_clip_new ();
fail_unless (object != NULL);
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -72,11 +72,11 @@ GST_START_TEST (test_test_source_properties)
51, 0, TRUE);
/* Change more properties, see if they propagate */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510,
"in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120);
@ -86,15 +86,15 @@ GST_START_TEST (test_test_source_properties)
120, 510, 0, TRUE);
/* Test mute support */
g_object_set (object, "mute", TRUE, NULL);
g_object_set (clip, "mute", TRUE, NULL);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, FALSE);
g_object_set (object, "mute", FALSE, NULL);
g_object_set (clip, "mute", FALSE, NULL);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, TRUE);
ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
ges_clip_release_track_element (clip, trackelement);
g_object_unref (clip);
}
GST_END_TEST;
@ -104,7 +104,7 @@ GST_START_TEST (test_test_source_in_layer)
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
GESTrackElement *trobj;
GESTrackElement *track_element;
GESTestClip *source;
GESVideoTestPattern ptrn;
gdouble freq, volume;
@ -134,22 +134,22 @@ GST_START_TEST (test_test_source_in_layer)
g_object_get (source, "vpattern", &ptrn, NULL);
assert_equals_int (ptrn, GES_VIDEO_TEST_PATTERN_WHITE);
trobj =
track_element =
ges_clip_find_track_element (GES_CLIP (source), v,
GES_TYPE_VIDEO_TEST_SOURCE);
g_assert (GES_IS_VIDEO_TEST_SOURCE (trobj));
g_assert (GES_IS_VIDEO_TEST_SOURCE (track_element));
ptrn = (ges_video_test_source_get_pattern ((GESVideoTestSource *)
trobj));
track_element));
assert_equals_int (ptrn, GES_VIDEO_TEST_PATTERN_WHITE);
g_object_unref (trobj);
g_object_unref (track_element);
/* test audio properties as well */
trobj = ges_clip_find_track_element (GES_CLIP (source),
track_element = ges_clip_find_track_element (GES_CLIP (source),
a, GES_TYPE_AUDIO_TEST_SOURCE);
g_assert (GES_IS_AUDIO_TEST_SOURCE (trobj));
g_assert (GES_IS_AUDIO_TEST_SOURCE (track_element));
assert_equals_float (ges_test_clip_get_frequency (source), 440);
assert_equals_float (ges_test_clip_get_volume (source), 0);
@ -158,8 +158,9 @@ GST_START_TEST (test_test_source_in_layer)
assert_equals_float (volume, 0);
freq = ges_audio_test_source_get_freq (GES_AUDIO_TEST_SOURCE (trobj));
volume = ges_audio_test_source_get_volume (GES_AUDIO_TEST_SOURCE (trobj));
freq = ges_audio_test_source_get_freq (GES_AUDIO_TEST_SOURCE (track_element));
volume =
ges_audio_test_source_get_volume (GES_AUDIO_TEST_SOURCE (track_element));
g_assert (freq == 440);
g_assert (volume == 0);
@ -170,12 +171,13 @@ GST_START_TEST (test_test_source_in_layer)
assert_equals_float (freq, 2000);
assert_equals_float (volume, 0.5);
freq = ges_audio_test_source_get_freq (GES_AUDIO_TEST_SOURCE (trobj));
volume = ges_audio_test_source_get_volume (GES_AUDIO_TEST_SOURCE (trobj));
freq = ges_audio_test_source_get_freq (GES_AUDIO_TEST_SOURCE (track_element));
volume =
ges_audio_test_source_get_volume (GES_AUDIO_TEST_SOURCE (track_element));
g_assert (freq == 2000);
g_assert (volume == 0.5);
g_object_unref (trobj);
g_object_unref (track_element);
ges_timeline_layer_remove_clip (layer, (GESClip *) source);
@ -230,7 +232,7 @@ GST_START_TEST (test_gap_filling_basic)
GESTrack *track;
GESTrackElement *trackelement, *trackelement1, *trackelement2;
/*GESTimelineLayer *layer; */
GESClip *object, *object1, *object2;
GESClip *clip, *clip1, *clip2;
GstElement *gnlsrc, *gnlsrc1, *gap = NULL;
GstElement *composition;
GList *tmp;
@ -243,16 +245,16 @@ GST_START_TEST (test_gap_filling_basic)
composition = find_composition (track);
fail_unless (composition != NULL);
object = GES_CLIP (ges_test_clip_new ());
fail_unless (object != NULL);
clip = GES_CLIP (ges_test_clip_new ());
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 0, "duration", (guint64) 5, NULL);
assert_equals_uint64 (_START (object), 0);
assert_equals_uint64 (_DURATION (object), 5);
g_object_set (clip, "start", (guint64) 0, "duration", (guint64) 5, NULL);
assert_equals_uint64 (_START (clip), 0);
assert_equals_uint64 (_DURATION (clip), 5);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (ges_track_add_element (track, trackelement));
fail_unless (trackelement != NULL);
@ -266,15 +268,15 @@ GST_START_TEST (test_gap_filling_basic)
/* Check no gap were wrongly added */
assert_equals_int (g_list_length (GST_BIN_CHILDREN (composition)), 1);
object1 = GES_CLIP (ges_test_clip_new ());
fail_unless (object1 != NULL);
clip1 = GES_CLIP (ges_test_clip_new ());
fail_unless (clip1 != NULL);
g_object_set (object1, "start", (guint64) 15, "duration", (guint64) 5, NULL);
assert_equals_uint64 (_START (object1), 15);
assert_equals_uint64 (_DURATION (object1), 5);
g_object_set (clip1, "start", (guint64) 15, "duration", (guint64) 5, NULL);
assert_equals_uint64 (_START (clip1), 15);
assert_equals_uint64 (_DURATION (clip1), 5);
trackelement1 = ges_clip_create_track_element (object1, track->type);
ges_clip_add_track_element (object1, trackelement1);
trackelement1 = ges_clip_create_track_element (clip1, track->type);
ges_clip_add_track_element (clip1, trackelement1);
fail_unless (ges_track_add_element (track, trackelement1));
fail_unless (trackelement1 != NULL);
gnlsrc1 = ges_track_element_get_gnlobject (trackelement1);
@ -295,13 +297,13 @@ GST_START_TEST (test_gap_filling_basic)
}
}
fail_unless (gap != NULL);
gap_object_check (gap, 5, 10, 0)
gap_object_check (gap, 5, 10, 0);
object2 = GES_CLIP (ges_test_clip_new ());
fail_unless (object2 != NULL);
g_object_set (object2, "start", (guint64) 35, "duration", (guint64) 5, NULL);
trackelement2 = ges_clip_create_track_element (object2, track->type);
ges_clip_add_track_element (object2, trackelement2);
clip2 = GES_CLIP (ges_test_clip_new ());
fail_unless (clip2 != NULL);
g_object_set (clip2, "start", (guint64) 35, "duration", (guint64) 5, NULL);
trackelement2 = ges_clip_create_track_element (clip2, track->type);
ges_clip_add_track_element (clip2, trackelement2);
fail_unless (ges_track_add_element (track, trackelement2));
fail_unless (trackelement2 != NULL);
assert_equals_uint64 (_START (trackelement2), 35);

12
tests/check/ges/basic.c
View file

@ -31,13 +31,13 @@ GST_START_TEST (test_ges_init)
GST_END_TEST;
static gboolean
my_fill_track_func (GESClip * object,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
my_fill_track_func (GESClip * clip,
GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelement:%p, gnlobj:%p",
object, trobject, gnlobj);
clip, track_element, gnlobj);
/* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL);
@ -564,13 +564,13 @@ typedef struct
} SelectTracksData;
static GPtrArray *
select_tracks_cb (GESTimeline * timeline, GESClip * tobj,
GESTrackElement * trobj, SelectTracksData * st_data)
select_tracks_cb (GESTimeline * timeline, GESClip * clip,
GESTrackElement * track_element, SelectTracksData * st_data)
{
GESTrack *track;
GPtrArray *ret = g_ptr_array_new ();
track = (tobj == (GESClip *) * st_data->o2) ? *st_data->tr2 : *st_data->tr1;
track = (clip == (GESClip *) * st_data->o2) ? *st_data->tr2 : *st_data->tr1;
gst_object_ref (track);

120
tests/check/ges/clip.c
View file

@ -22,13 +22,13 @@
#include <gst/check/gstcheck.h>
static gboolean
my_fill_track_func (GESClip * object,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
my_fill_track_func (GESClip * clip,
GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p",
object, trobject, gnlobj);
clip, track_element, gnlobj);
/* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL);
@ -43,25 +43,25 @@ GST_START_TEST (test_object_properties)
{
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL);
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL);
clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -75,11 +75,11 @@ GST_START_TEST (test_object_properties)
51, 0, TRUE);
/* Change more properties, see if they propagate */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510,
"in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120);
@ -90,16 +90,16 @@ GST_START_TEST (test_object_properties)
/* This time, we move the trackelement to see if the changes move
* along to the parent and the gnonlin object */
* along to the parent and the gnonlin clip */
g_object_set (trackelement, "start", (guint64) 400, NULL);
assert_equals_uint64 (_START (object), 400);
assert_equals_uint64 (_START (clip), 400);
assert_equals_uint64 (_START (trackelement), 400);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 510,
120, 510, 0, TRUE);
ges_clip_release_track_element (object, trackelement);
ges_clip_release_track_element (clip, trackelement);
g_object_unref (object);
g_object_unref (clip);
g_object_unref (track);
}
@ -109,25 +109,25 @@ GST_START_TEST (test_object_properties_unlocked)
{
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL);
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL);
clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -144,33 +144,33 @@ GST_START_TEST (test_object_properties_unlocked)
ges_track_element_set_locked (trackelement, FALSE);
/* Change more properties, they will be set on the GESClip */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510,
"in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (clip), 120);
/* ... but not on the GESTrackElement since it was unlocked... */
assert_equals_uint64 (_START (trackelement), 42);
assert_equals_uint64 (_DURATION (trackelement), 51);
assert_equals_uint64 (_INPOINT (trackelement), 12);
/* ... and neither on the GNonLin object */
/* ... and neither on the GNonLin clip */
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* When unlocked, moving the GESTrackElement won't move the GESClip
* either */
/* This time, we move the trackelement to see if the changes move
* along to the parent and the gnonlin object */
* along to the parent and the gnonlin clip */
g_object_set (trackelement, "start", (guint64) 400, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_START (trackelement), 400);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 51, 12,
51, 0, TRUE);
ges_clip_release_track_element (object, trackelement);
ges_clip_release_track_element (clip, trackelement);
g_object_unref (object);
g_object_unref (clip);
g_object_unref (track);
}
@ -180,7 +180,7 @@ GST_START_TEST (test_split_object)
{
GESTrack *track;
GESTrackElement *trackelement, *splittrackelement;
GESClip *object, *splitobj;
GESClip *clip, *splitclip;
GList *splittrackelements;
ges_init ();
@ -188,18 +188,18 @@ GST_START_TEST (test_split_object)
track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL);
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL);
clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 50,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 50,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 50);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 50);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -212,18 +212,18 @@ GST_START_TEST (test_split_object)
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 50, 12,
50, 0, TRUE);
splitobj = ges_clip_split (object, 67);
fail_unless (GES_IS_CLIP (splitobj));
splitclip = ges_clip_split (clip, 67);
fail_unless (GES_IS_CLIP (splitclip));
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 25);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 25);
assert_equals_uint64 (_INPOINT (clip), 12);
assert_equals_uint64 (_START (splitobj), 67);
assert_equals_uint64 (_DURATION (splitobj), 25);
assert_equals_uint64 (_INPOINT (splitobj), 37);
assert_equals_uint64 (_START (splitclip), 67);
assert_equals_uint64 (_DURATION (splitclip), 25);
assert_equals_uint64 (_INPOINT (splitclip), 37);
splittrackelements = ges_clip_get_track_elements (splitobj);
splittrackelements = ges_clip_get_track_elements (splitclip);
fail_unless_equals_int (g_list_length (splittrackelements), 1);
splittrackelement = GES_TRACK_ELEMENT (splittrackelements->data);
@ -233,16 +233,16 @@ GST_START_TEST (test_split_object)
assert_equals_uint64 (_INPOINT (splittrackelement), 37);
fail_unless (splittrackelement != trackelement);
fail_unless (splitobj != object);
fail_unless (splitclip != clip);
/* We own the only ref */
ASSERT_OBJECT_REFCOUNT (splitobj, "splitobj", 1);
ASSERT_OBJECT_REFCOUNT (splitclip, "splitclip", 1);
/* 1 ref for the Clip, 1 ref for the Track and 1 in splittrackelements */
ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 3);
g_object_unref (track);
g_object_unref (splitobj);
g_object_unref (object);
g_object_unref (splitclip);
g_object_unref (clip);
ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 1);
g_list_free_full (splittrackelements, g_object_unref);

12
tests/check/ges/effects.c
View file

@ -21,9 +21,9 @@
#include <ges/ges.h>
#include <gst/check/gstcheck.h>
void effect_added_cb (GESClip * obj, GESBaseEffect * trop, gpointer data);
void effect_added_cb (GESClip * clip, GESBaseEffect * trop, gpointer data);
void
deep_prop_changed_cb (GESTrackElement * obj, GstElement * element,
deep_prop_changed_cb (GESTrackElement * track_element, GstElement * element,
GParamSpec * spec);
GST_START_TEST (test_effect_basic)
@ -383,19 +383,19 @@ GST_START_TEST (test_base_effect_set_properties)
GST_END_TEST;
void
effect_added_cb (GESClip * obj, GESBaseEffect * trop, gpointer data)
effect_added_cb (GESClip * clip, GESBaseEffect * trop, gpointer data)
{
GST_DEBUG ("Effect added");
fail_unless (GES_IS_CLIP (obj));
fail_unless (GES_IS_CLIP (clip));
fail_unless (GES_IS_BASE_EFFECT (trop));
}
void
deep_prop_changed_cb (GESTrackElement * obj, GstElement * element,
deep_prop_changed_cb (GESTrackElement * track_element, GstElement * element,
GParamSpec * spec)
{
GST_DEBUG ("%s property changed", g_param_spec_get_name (spec));
fail_unless (GES_IS_TRACK_ELEMENT (obj));
fail_unless (GES_IS_TRACK_ELEMENT (track_element));
fail_unless (GST_IS_ELEMENT (element));
}

146
tests/check/ges/layer.c
View file

@ -24,13 +24,13 @@
#define LAYER_HEIGHT 1000
static gboolean
my_fill_track_func (GESClip * object,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
my_fill_track_func (GESClip * clip,
GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p",
object, trobject, gnlobj);
clip, track_element, gnlobj);
/* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL);
@ -48,7 +48,7 @@ GST_START_TEST (test_layer_properties)
GESTimelineLayer *layer;
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
@ -69,55 +69,55 @@ GST_START_TEST (test_layer_properties)
fail_unless (track != NULL);
fail_unless (ges_timeline_add_track (timeline, track));
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL);
clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_PRIORITY (object), 0);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
assert_equals_uint64 (_PRIORITY (clip), 0);
/* Add the object to the timeline */
fail_unless (g_object_is_floating (object));
fail_unless (ges_timeline_layer_add_clip (layer, GES_CLIP (object)));
fail_if (g_object_is_floating (object));
trackelement = ges_clip_find_track_element (object, track, G_TYPE_NONE);
/* Add the clip to the timeline */
fail_unless (g_object_is_floating (clip));
fail_unless (ges_timeline_layer_add_clip (layer, GES_CLIP (clip)));
fail_if (g_object_is_floating (clip));
trackelement = ges_clip_find_track_element (clip, track, G_TYPE_NONE);
fail_unless (trackelement != NULL);
/* This is not a SimpleLayer, therefore the properties shouldn't have changed */
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_PRIORITY (object), 0);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
assert_equals_uint64 (_PRIORITY (clip), 0);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change the priority of the layer */
g_object_set (layer, "priority", 1, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 1);
assert_equals_uint64 (_PRIORITY (object), 0);
assert_equals_uint64 (_PRIORITY (clip), 0);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, LAYER_HEIGHT, TRUE);
/* Change it to an insanely high value */
g_object_set (layer, "priority", 31, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 31);
assert_equals_uint64 (_PRIORITY (object), 0);
assert_equals_uint64 (_PRIORITY (clip), 0);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, LAYER_HEIGHT * 31, TRUE);
/* and back to 0 */
g_object_set (layer, "priority", 0, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 0);
assert_equals_uint64 (_PRIORITY (object), 0);
assert_equals_uint64 (_PRIORITY (clip), 0);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
g_object_unref (trackelement);
fail_unless (ges_timeline_layer_remove_clip (layer, object));
fail_unless (ges_timeline_layer_remove_clip (layer, clip));
fail_unless (ges_timeline_remove_track (timeline, track));
fail_unless (ges_timeline_remove_layer (timeline, layer));
g_object_unref (timeline);
@ -131,7 +131,7 @@ GST_START_TEST (test_layer_priorities)
GESTimeline *timeline;
GESTimelineLayer *layer1, *layer2, *layer3;
GESTrackElement *trackelement1, *trackelement2, *trackelement3;
GESClip *object1, *object2, *object3;
GESClip *clip1, *clip2, *clip3;
GstElement *gnlobj1, *gnlobj2, *gnlobj3;
guint prio1, prio2, prio3;
GList *objs, *tmp;
@ -158,57 +158,57 @@ GST_START_TEST (test_layer_priorities)
fail_unless (track != NULL);
fail_unless (ges_timeline_add_track (timeline, track));
object1 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (object1,
clip1 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (clip1,
GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO);
object2 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (object2,
clip2 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (clip2,
GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO);
object3 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (object3,
clip3 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (clip3,
GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO);
fail_unless (object1 != NULL);
fail_unless (object2 != NULL);
fail_unless (object3 != NULL);
fail_unless (clip1 != NULL);
fail_unless (clip2 != NULL);
fail_unless (clip3 != NULL);
/* Set priorities on the objects */
g_object_set (object1, "priority", 0, NULL);
assert_equals_int (_PRIORITY (object1), 0);
g_object_set (object2, "priority", 1, NULL);
assert_equals_int (_PRIORITY (object2), 1);
g_object_set (object3, "priority", LAYER_HEIGHT + 1, NULL);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT + 1);
g_object_set (clip1, "priority", 0, NULL);
assert_equals_int (_PRIORITY (clip1), 0);
g_object_set (clip2, "priority", 1, NULL);
assert_equals_int (_PRIORITY (clip2), 1);
g_object_set (clip3, "priority", LAYER_HEIGHT + 1, NULL);
assert_equals_int (_PRIORITY (clip3), LAYER_HEIGHT + 1);
/* Add objects to the timeline */
fail_unless (ges_timeline_layer_add_clip (layer1, object1));
trackelement1 = ges_clip_find_track_element (object1, track, G_TYPE_NONE);
fail_unless (ges_timeline_layer_add_clip (layer1, clip1));
trackelement1 = ges_clip_find_track_element (clip1, track, G_TYPE_NONE);
fail_unless (trackelement1 != NULL);
fail_unless (ges_timeline_layer_add_clip (layer2, object2));
trackelement2 = ges_clip_find_track_element (object2, track, G_TYPE_NONE);
fail_unless (ges_timeline_layer_add_clip (layer2, clip2));
trackelement2 = ges_clip_find_track_element (clip2, track, G_TYPE_NONE);
fail_unless (trackelement2 != NULL);
fail_unless (ges_timeline_layer_add_clip (layer3, object3));
trackelement3 = ges_clip_find_track_element (object3, track, G_TYPE_NONE);
fail_unless (ges_timeline_layer_add_clip (layer3, clip3));
trackelement3 = ges_clip_find_track_element (clip3, track, G_TYPE_NONE);
fail_unless (trackelement3 != NULL);
assert_equals_int (_PRIORITY (object1), 0);
assert_equals_int (_PRIORITY (clip1), 0);
gnlobj1 = ges_track_element_get_gnlobject (trackelement1);
fail_unless (gnlobj1 != NULL);
g_object_get (gnlobj1, "priority", &prio1, NULL);
assert_equals_int (prio1, 0);
assert_equals_int (_PRIORITY (object2), 1);
assert_equals_int (_PRIORITY (clip2), 1);
gnlobj2 = ges_track_element_get_gnlobject (trackelement2);
fail_unless (gnlobj2 != NULL);
g_object_get (gnlobj2, "priority", &prio2, NULL);
/* object2 is on the second layer and has a priority of 1 */
/* clip2 is on the second layer and has a priority of 1 */
assert_equals_int (prio2, LAYER_HEIGHT + 1);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT - 1);
assert_equals_int (_PRIORITY (clip3), LAYER_HEIGHT - 1);
gnlobj3 = ges_track_element_get_gnlobject (trackelement3);
fail_unless (gnlobj3 != NULL);
/* object3 is on the third layer and has a priority of LAYER_HEIGHT + 1
/* clip3 is on the third layer and has a priority of LAYER_HEIGHT + 1
* it priority must have the maximum priority of this layer*/
g_object_get (gnlobj3, "priority", &prio3, NULL);
assert_equals_int (prio3, LAYER_HEIGHT * 3 - 1);
@ -222,9 +222,9 @@ GST_START_TEST (test_layer_priorities)
assert_equals_int (ges_timeline_layer_get_priority (layer1), 2);
assert_equals_int (ges_timeline_layer_get_priority (layer2), 0);
assert_equals_int (ges_timeline_layer_get_priority (layer3), 1);
assert_equals_int (_PRIORITY (object1), 0);
assert_equals_int (_PRIORITY (object2), 1);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT - 1);
assert_equals_int (_PRIORITY (clip1), 0);
assert_equals_int (_PRIORITY (clip2), 1);
assert_equals_int (_PRIORITY (clip3), LAYER_HEIGHT - 1);
g_object_get (gnlobj1, "priority", &prio1, NULL);
g_object_get (gnlobj2, "priority", &prio2, NULL);
g_object_get (gnlobj3, "priority", &prio3, NULL);
@ -233,8 +233,8 @@ GST_START_TEST (test_layer_priorities)
assert_equals_int (prio3, LAYER_HEIGHT * 2 - 1);
/* And move objects around */
fail_unless (ges_clip_move_to_layer (object2, layer1));
fail_unless (ges_clip_move_to_layer (object3, layer1));
fail_unless (ges_clip_move_to_layer (clip2, layer1));
fail_unless (ges_clip_move_to_layer (clip3, layer1));
objs = ges_timeline_layer_get_clips (layer1);
assert_equals_int (g_list_length (objs), 3);
@ -247,9 +247,9 @@ GST_START_TEST (test_layer_priorities)
g_list_free (objs);
/* Check their priorities (layer1 priority is now 2) */
assert_equals_int (_PRIORITY (object1), 0);
assert_equals_int (_PRIORITY (object2), 1);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT - 1);
assert_equals_int (_PRIORITY (clip1), 0);
assert_equals_int (_PRIORITY (clip2), 1);
assert_equals_int (_PRIORITY (clip3), LAYER_HEIGHT - 1);
g_object_get (gnlobj1, "priority", &prio1, NULL);
g_object_get (gnlobj2, "priority", &prio2, NULL);
g_object_get (gnlobj3, "priority", &prio3, NULL);
@ -263,7 +263,7 @@ GST_START_TEST (test_layer_priorities)
LAYER_HEIGHT * 2);
g_object_get (gnlobj3, "priority", &prio3, NULL);
assert_equals_int (prio3, 2 * LAYER_HEIGHT);
assert_equals_int (_PRIORITY (object3), 0);
assert_equals_int (_PRIORITY (clip3), 0);
g_object_unref (trackelement1);
g_object_unref (trackelement2);
@ -305,12 +305,12 @@ GST_START_TEST (test_single_layer_automatic_transition)
fail_unless (ges_timeline_layer_get_auto_transition (layer));
GST_DEBUG ("Adding assets to first layer");
GST_DEBUG ("Adding object from 0 -- 1000 to first layer");
GST_DEBUG ("Adding clip from 0 -- 1000 to first layer");
src = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 0, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src));
GST_DEBUG ("Adding object from 500 -- 1000 to first layer");
GST_DEBUG ("Adding clip from 500 -- 1000 to first layer");
src1 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src1));
@ -479,7 +479,7 @@ GST_START_TEST (test_single_layer_automatic_transition)
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Adding asset to first layer");
GST_DEBUG ("Adding object from 1250 -- 1000 to first layer");
GST_DEBUG ("Adding clip from 1250 -- 1000 to first layer");
src2 =
GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 1250, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN));
@ -576,7 +576,7 @@ GST_START_TEST (test_single_layer_automatic_transition)
g_list_free_full (objects, gst_object_unref);
GST_DEBUG
("Set third object start to 1100, 1 new transition should be created");
("Set third clip start to 1100, 1 new transition should be created");
ges_timeline_element_set_start (src2, 1100);
/* 600____src___1100
* 500___________src1________1250
@ -614,7 +614,7 @@ GST_START_TEST (test_single_layer_automatic_transition)
fail_unless (current->data == src2);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Set third object start to 1000, Transition should be updated");
GST_DEBUG ("Set third clip start to 1000, Transition should be updated");
ges_clip_edit (GES_CLIP (src2), NULL, -1,
GES_EDIT_MODE_NORMAL, GES_EDGE_START, 1000);
/* 600____src___1100
@ -709,12 +709,12 @@ GST_START_TEST (test_multi_layer_automatic_transition)
fail_if (ges_timeline_layer_get_auto_transition (layer1));
GST_DEBUG ("Adding assets to first layer");
GST_DEBUG ("Adding object from 0 -- 1000 to first layer");
GST_DEBUG ("Adding clip from 0 -- 1000 to first layer");
src = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 0, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src));
GST_DEBUG ("Adding object from 500 -- 1000 to first layer");
GST_DEBUG ("Adding clip from 500 -- 1000 to first layer");
src1 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src1));
@ -749,10 +749,10 @@ GST_START_TEST (test_multi_layer_automatic_transition)
g_list_free_full (objects, gst_object_unref);
ASSERT_OBJECT_REFCOUNT (transition, "Only the layer owns a ref", 1);
GST_DEBUG ("Adding object 2 from 500 -- 1000 to second layer");
GST_DEBUG ("Adding clip 2 from 500 -- 1000 to second layer");
src2 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer1, asset, 0,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
GST_DEBUG ("Adding object 3 from 500 -- 1000 to second layer");
GST_DEBUG ("Adding clip 3 from 500 -- 1000 to second layer");
src3 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer1, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
assert_is_type (src3, GES_TYPE_TEST_CLIP);
@ -1183,22 +1183,22 @@ GST_START_TEST (test_layer_activate_automatic_transition)
layer = ges_timeline_append_layer (timeline);
assert_is_type (layer, GES_TYPE_TIMELINE_LAYER);
GST_DEBUG ("Adding object from 0 -- 1000 to layer");
GST_DEBUG ("Adding clip from 0 -- 1000 to layer");
src = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 0, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src));
GST_DEBUG ("Adding object from 500 -- 1000 to first layer");
GST_DEBUG ("Adding clip from 500 -- 1000 to first layer");
src1 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src1));
GST_DEBUG ("Adding object from 1000 -- 2000 to layer");
GST_DEBUG ("Adding clip from 1000 -- 2000 to layer");
src2 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 1000,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src2));
GST_DEBUG ("Adding object from 2000 -- 2500 to layer");
GST_DEBUG ("Adding clip from 2000 -- 2500 to layer");
src3 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 2000,
0, 500, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src3));

50
tests/check/ges/overlays.c
View file

@ -39,26 +39,25 @@ GST_START_TEST (test_overlay_properties)
{
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
track = ges_track_new (GES_TRACK_TYPE_VIDEO, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL);
object = (GESClip *)
ges_text_overlay_clip_new ();
fail_unless (object != NULL);
clip = (GESClip *) ges_text_overlay_clip_new ();
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -72,11 +71,11 @@ GST_START_TEST (test_overlay_properties)
51, 0, TRUE);
/* Change more properties, see if they propagate */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510,
"in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120);
@ -85,8 +84,8 @@ GST_START_TEST (test_overlay_properties)
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, TRUE);
ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
ges_clip_release_track_element (clip, trackelement);
g_object_unref (clip);
}
GST_END_TEST;
@ -96,7 +95,7 @@ GST_START_TEST (test_overlay_in_layer)
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
GESTrackElement *trobj;
GESTrackElement *track_element;
GESTextOverlayClip *source;
gchar *text;
gint halign, valign;
@ -128,7 +127,8 @@ GST_START_TEST (test_overlay_in_layer)
assert_equals_string ("some text", text);
g_free (text);
trobj = ges_clip_find_track_element (GES_CLIP (source), v, G_TYPE_NONE);
track_element =
ges_clip_find_track_element (GES_CLIP (source), v, G_TYPE_NONE);
/* test the font-desc property */
g_object_set (source, "font-desc", (gchar *) "sans 72", NULL);
@ -137,7 +137,7 @@ GST_START_TEST (test_overlay_in_layer)
g_free (text);
assert_equals_string ("sans 72",
ges_text_overlay_get_font_desc (GES_TEXT_OVERLAY (trobj)));
ges_text_overlay_get_font_desc (GES_TEXT_OVERLAY (track_element)));
/* test halign and valign */
g_object_set (source, "halignment", (gint)
@ -146,8 +146,8 @@ GST_START_TEST (test_overlay_in_layer)
assert_equals_int (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP);
halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (trobj));
valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (trobj));
halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (track_element));
valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (track_element));
assert_equals_int (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP);
@ -156,7 +156,7 @@ GST_START_TEST (test_overlay_in_layer)
g_object_get (source, "color", &color, NULL);
assert_equals_int (color, 2147483647);
color = ges_text_overlay_get_color (GES_TEXT_OVERLAY (trobj));
color = ges_text_overlay_get_color (GES_TEXT_OVERLAY (track_element));
assert_equals_int (color, 2147483647);
/* test xpos */
@ -164,7 +164,7 @@ GST_START_TEST (test_overlay_in_layer)
g_object_get (source, "xpos", &xpos, NULL);
assert_equals_float (xpos, 0.5);
xpos = ges_text_overlay_get_xpos (GES_TEXT_OVERLAY (trobj));
xpos = ges_text_overlay_get_xpos (GES_TEXT_OVERLAY (track_element));
assert_equals_float (xpos, 0.5);
/* test ypos */
@ -172,7 +172,7 @@ GST_START_TEST (test_overlay_in_layer)
g_object_get (source, "ypos", &ypos, NULL);
assert_equals_float (ypos, 0.33);
ypos = ges_text_overlay_get_ypos (GES_TEXT_OVERLAY (trobj));
ypos = ges_text_overlay_get_ypos (GES_TEXT_OVERLAY (track_element));
assert_equals_float (ypos, 0.33);
GST_DEBUG ("removing the source");
@ -181,7 +181,7 @@ GST_START_TEST (test_overlay_in_layer)
GST_DEBUG ("removing the layer");
g_object_unref (trobj);
g_object_unref (track_element);
g_object_unref (timeline);
}

14
tests/check/ges/simplelayer.c
View file

@ -22,13 +22,13 @@
#include <gst/check/gstcheck.h>
static gboolean
my_fill_track_func (GESClip * object,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
my_fill_track_func (GESClip * clip,
GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p",
object, trobject, gnlobj);
clip, track_element, gnlobj);
/* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL);
@ -41,15 +41,15 @@ my_fill_track_func (GESClip * object,
}
static gboolean
arbitrary_fill_track_func (GESClip * object,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
arbitrary_fill_track_func (GESClip * clip,
GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
g_assert (user_data);
GST_DEBUG ("element:%s, timelineobj:%p, trackelements:%p, gnlobj:%p,",
(const gchar *) user_data, object, trobject, gnlobj);
(const gchar *) user_data, clip, track_element, gnlobj);
/* interpret user_data as name of element to create */
src = gst_element_factory_make (user_data, NULL);
@ -126,7 +126,7 @@ typedef struct
static void
object_moved_cb (GESSimpleTimelineLayer * layer,
GESClip * object, gint old, gint new, gpointer user)
GESClip * clip, gint old, gint new, gpointer user)
{
siginfo *info;
info = (siginfo *) user;

20
tests/check/ges/text_properties.c
View file

@ -26,7 +26,7 @@ GST_START_TEST (test_text_properties_in_layer)
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
GESTrackElement *trobj;
GESTrackElement *track_element;
GESTestClip *source;
gchar *text;
gint halign, valign;
@ -49,11 +49,11 @@ GST_START_TEST (test_text_properties_in_layer)
ges_simple_timeline_layer_add_object ((GESSimpleTimelineLayer *) layer,
(GESClip *) source, 0);
trobj =
track_element =
ges_clip_find_track_element (GES_CLIP (source), v, GES_TYPE_TEXT_OVERLAY);
fail_unless (trobj != NULL);
assert_equals_int (trobj->active, FALSE);
fail_unless (track_element != NULL);
assert_equals_int (track_element->active, FALSE);
/* specifically test the text property */
g_object_set (source, "text", (gchar *) "some text", NULL);
@ -61,7 +61,7 @@ GST_START_TEST (test_text_properties_in_layer)
assert_equals_string ("some text", text);
g_free (text);
assert_equals_int (trobj->active, TRUE);
assert_equals_int (track_element->active, TRUE);
/* test the font-desc property */
g_object_set (source, "font-desc", (gchar *) "sans 72", NULL);
@ -70,10 +70,10 @@ GST_START_TEST (test_text_properties_in_layer)
g_free (text);
assert_equals_string ("sans 72",
ges_text_overlay_get_font_desc (GES_TEXT_OVERLAY (trobj)));
ges_text_overlay_get_font_desc (GES_TEXT_OVERLAY (track_element)));
g_object_set (source, "text", (gchar *) NULL, NULL);
assert_equals_int (trobj->active, FALSE);
assert_equals_int (track_element->active, FALSE);
/* test halign and valign */
g_object_set (source, "halignment", (gint)
@ -82,8 +82,8 @@ GST_START_TEST (test_text_properties_in_layer)
assert_equals_int (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP);
halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (trobj));
valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (trobj));
halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (track_element));
valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (track_element));
assert_equals_int (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP);
@ -93,7 +93,7 @@ GST_START_TEST (test_text_properties_in_layer)
GST_DEBUG ("removing the layer");
g_object_unref (trobj);
g_object_unref (track_element);
g_object_unref (timeline);
}

405
tests/check/ges/timelineedition.c
View file

File diff suppressed because it is too large Load diff

50
tests/check/ges/titles.c
View file

@ -39,26 +39,26 @@ GST_START_TEST (test_title_source_properties)
{
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
track = ges_track_video_raw_new ();
fail_unless (track != NULL);
object = (GESClip *)
clip = (GESClip *)
ges_title_clip_new ();
fail_unless (object != NULL);
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -72,11 +72,11 @@ GST_START_TEST (test_title_source_properties)
51, 0, TRUE);
/* Change more properties, see if they propagate */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510,
"in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120);
@ -85,8 +85,8 @@ GST_START_TEST (test_title_source_properties)
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, TRUE);
ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
ges_clip_release_track_element (clip, trackelement);
g_object_unref (clip);
}
GST_END_TEST;
@ -96,7 +96,7 @@ GST_START_TEST (test_title_source_in_layer)
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
GESTrackElement *trobj;
GESTrackElement *track_element;
GESTitleClip *source;
gchar *text;
gint halign, valign;
@ -128,12 +128,12 @@ GST_START_TEST (test_title_source_in_layer)
assert_equals_string ("some text", text);
g_free (text);
trobj =
track_element =
ges_clip_find_track_element (GES_CLIP (source), v, GES_TYPE_TITLE_SOURCE);
/* Check the text is still the same */
assert_equals_string (ges_title_source_get_text (GES_TITLE_SOURCE
(trobj)), "some text");
(track_element)), "some text");
/* test the font-desc property */
g_object_set (source, "font-desc", (gchar *) "sans 72", NULL);
@ -142,7 +142,7 @@ GST_START_TEST (test_title_source_in_layer)
g_free (text);
assert_equals_string ("sans 72",
ges_title_source_get_font_desc (GES_TITLE_SOURCE (trobj)));
ges_title_source_get_font_desc (GES_TITLE_SOURCE (track_element)));
/* test halign and valign */
g_object_set (source, "halignment", (gint)
@ -152,16 +152,16 @@ GST_START_TEST (test_title_source_in_layer)
assert_equals_int (valign, GES_TEXT_VALIGN_TOP);
assert_equals_int (ges_title_source_get_halignment
(GES_TITLE_SOURCE (trobj)), GES_TEXT_HALIGN_LEFT);
(GES_TITLE_SOURCE (track_element)), GES_TEXT_HALIGN_LEFT);
assert_equals_int (ges_title_source_get_valignment
(GES_TITLE_SOURCE (trobj)), GES_TEXT_VALIGN_TOP);
(GES_TITLE_SOURCE (track_element)), GES_TEXT_VALIGN_TOP);
/* test color */
g_object_set (source, "color", (gint) 2147483647, NULL);
g_object_get (source, "color", &color, NULL);
assert_equals_int (color, 2147483647);
color = ges_title_source_get_text_color (GES_TITLE_SOURCE (trobj));
color = ges_title_source_get_text_color (GES_TITLE_SOURCE (track_element));
assert_equals_int (color, 2147483647);
/* test xpos */
@ -169,7 +169,7 @@ GST_START_TEST (test_title_source_in_layer)
g_object_get (source, "xpos", &xpos, NULL);
assert_equals_float (xpos, 0.25);
xpos = ges_title_source_get_xpos (GES_TITLE_SOURCE (trobj));
xpos = ges_title_source_get_xpos (GES_TITLE_SOURCE (track_element));
assert_equals_float (xpos, 0.25);
/* test ypos */
@ -177,7 +177,7 @@ GST_START_TEST (test_title_source_in_layer)
g_object_get (source, "ypos", &ypos, NULL);
assert_equals_float (ypos, 0.66);
xpos = ges_title_source_get_xpos (GES_TITLE_SOURCE (trobj));
xpos = ges_title_source_get_xpos (GES_TITLE_SOURCE (track_element));
assert_equals_float (ypos, 0.66);
GST_DEBUG ("removing the source");
@ -186,7 +186,7 @@ GST_START_TEST (test_title_source_in_layer)
GST_DEBUG ("removing the layer");
g_object_unref (trobj);
g_object_unref (track_element);
g_object_unref (timeline);
}

46
tests/check/ges/transition.c
View file

@ -66,11 +66,11 @@ GST_START_TEST (test_transition_properties)
{
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
object =
clip =
GES_CLIP (ges_transition_clip_new
(GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE));
@ -78,15 +78,15 @@ GST_START_TEST (test_transition_properties)
fail_unless (track != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -100,11 +100,11 @@ GST_START_TEST (test_transition_properties)
51, 0, TRUE);
/* Change more properties, see if they propagate */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510,
"in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120);
@ -115,9 +115,9 @@ GST_START_TEST (test_transition_properties)
/* test changing vtype */
GST_DEBUG ("Setting to crossfade");
g_object_set (object, "vtype", GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE,
g_object_set (clip, "vtype", GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE,
NULL);
assert_equals_int (GES_TRANSITION_CLIP (object)->vtype,
assert_equals_int (GES_TRANSITION_CLIP (clip)->vtype,
GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE);
assert_equals_int (ges_video_transition_get_transition_type
(GES_VIDEO_TRANSITION (trackelement)),
@ -126,20 +126,20 @@ GST_START_TEST (test_transition_properties)
/* Check that changing from crossfade to anything else fails (it should
* still be using crossfade */
GST_DEBUG ("Setting back to 1 (should fail)");
g_object_set (object, "vtype", 1, NULL);
g_object_set (clip, "vtype", 1, NULL);
assert_equals_int (GES_TRANSITION_CLIP (object)->vtype, 1);
assert_equals_int (GES_TRANSITION_CLIP (clip)->vtype, 1);
assert_equals_int (ges_video_transition_get_transition_type
(GES_VIDEO_TRANSITION (trackelement)), 1);
GST_DEBUG ("Releasing track element");
ges_clip_release_track_element (object, trackelement);
ges_clip_release_track_element (clip, trackelement);
g_object_set (object, "vtype", 1, NULL);
g_object_set (clip, "vtype", 1, NULL);
GST_DEBUG ("creating track element");
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -148,10 +148,10 @@ GST_START_TEST (test_transition_properties)
GST_DEBUG ("Setting to vtype:1");
assert_equals_int (ges_video_transition_get_transition_type
(GES_VIDEO_TRANSITION (trackelement)), 1);
assert_equals_int (GES_TRANSITION_CLIP (object)->vtype, 1);
assert_equals_int (GES_TRANSITION_CLIP (clip)->vtype, 1);
ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
ges_clip_release_track_element (clip, trackelement);
g_object_unref (clip);
g_object_unref (track);
}

56
tests/check/ges/uriclip.c
View file

@ -114,28 +114,28 @@ GST_START_TEST (test_filesource_properties)
{
GESTrack *track;
GESTrackElement *trackelement;
GESClip *object;
GESClip *clip;
ges_init ();
track = ges_track_new (GES_TRACK_TYPE_AUDIO, GST_CAPS_ANY);
fail_unless (track != NULL);
object = (GESClip *)
clip = (GESClip *)
ges_uri_clip_new ((gchar *)
"crack:///there/is/no/way/this/exists");
fail_unless (object != NULL);
fail_unless (clip != NULL);
/* Set some properties */
g_object_set (object, "start", (guint64) 42, "duration", (guint64) 51,
g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51,
"in-point", (guint64) 12, "supported-formats", GES_TRACK_TYPE_AUDIO,
NULL);
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type);
ges_clip_add_track_element (object, trackelement);
trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track));
@ -149,11 +149,11 @@ GST_START_TEST (test_filesource_properties)
51, 0, TRUE);
/* Change more properties, see if they propagate */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510,
"in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120);
@ -163,16 +163,16 @@ GST_START_TEST (test_filesource_properties)
120, 510, 0, TRUE);
/* Test mute support */
g_object_set (object, "mute", TRUE, NULL);
g_object_set (clip, "mute", TRUE, NULL);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, FALSE);
g_object_set (object, "mute", FALSE, NULL);
g_object_set (clip, "mute", FALSE, NULL);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, TRUE);
ges_clip_release_track_element (object, trackelement);
ges_clip_release_track_element (clip, trackelement);
g_object_unref (object);
g_object_unref (clip);
g_object_unref (track);
}
@ -180,7 +180,7 @@ GST_END_TEST;
GST_START_TEST (test_filesource_images)
{
GESTrackElement *trobj;
GESTrackElement *track_element;
GESClip *clip;
GESUriClip *uriclip;
GESTrack *a, *v;
@ -199,20 +199,20 @@ GST_START_TEST (test_filesource_images)
g_object_set (G_OBJECT (uriclip), "is-image", TRUE, NULL);
/* the returned track element should be an image source */
trobj = ges_clip_create_track_element (clip, v->type);
ges_clip_add_track_element (clip, trobj);
fail_unless (GES_IS_IMAGE_SOURCE (trobj));
track_element = ges_clip_create_track_element (clip, v->type);
ges_clip_add_track_element (clip, track_element);
fail_unless (GES_IS_IMAGE_SOURCE (track_element));
/* The track holds a reference to the object
* and the timelinobject holds a reference to the object */
ASSERT_OBJECT_REFCOUNT (trobj, "Video Track Element", 2);
/* The track holds a reference to the clip
* and the timelinobject holds a reference to the clip */
ASSERT_OBJECT_REFCOUNT (track_element, "Video Track Element", 2);
ges_track_remove_element (v, trobj);
ges_clip_release_track_element (clip, trobj);
ges_track_remove_element (v, track_element);
ges_clip_release_track_element (clip, track_element);
/* the clip should not create any TrackElement in the audio track */
trobj = ges_clip_create_track_element (clip, a->type);
fail_unless (trobj == NULL);
track_element = ges_clip_create_track_element (clip, a->type);
fail_unless (track_element == NULL);
g_object_unref (a);
g_object_unref (v);

210
tests/examples/ges-ui.c
View file

@ -213,12 +213,12 @@ update_play_sensitivity (App * app)
/* Backend callbacks ********************************************************/
static void
test_source_notify_volume_changed_cb (GESClip * object, GParamSpec *
test_source_notify_volume_changed_cb (GESClip * clip, GParamSpec *
unused G_GNUC_UNUSED, App * app)
{
gdouble volume;
g_object_get (G_OBJECT (object), "volume", &volume, NULL);
g_object_get (G_OBJECT (clip), "volume", &volume, NULL);
gtk_range_set_value (GTK_RANGE (app->volume), volume);
}
@ -231,18 +231,18 @@ layer_notify_valid_changed_cb (GObject * object, GParamSpec * unused
}
static gboolean
find_row_for_object (GtkListStore * model, GtkTreeIter * ret, GESClip * object)
find_row_for_object (GtkListStore * model, GtkTreeIter * ret, GESClip * clip)
{
gtk_tree_model_get_iter_first ((GtkTreeModel *) model, ret);
while (gtk_list_store_iter_is_valid (model, ret)) {
GESClip *obj;
gtk_tree_model_get ((GtkTreeModel *) model, ret, 2, &obj, -1);
if (obj == object) {
g_object_unref (obj);
GESClip *clip2;
gtk_tree_model_get ((GtkTreeModel *) model, ret, 2, &clip2, -1);
if (clip2 == clip) {
g_object_unref (clip2);
return TRUE;
}
g_object_unref (obj);
g_object_unref (clip2);
gtk_tree_model_iter_next ((GtkTreeModel *) model, ret);
}
return FALSE;
@ -251,14 +251,14 @@ find_row_for_object (GtkListStore * model, GtkTreeIter * ret, GESClip * object)
/* this callback is registered for every clip, and updates the
* corresponding duration cell in the model */
static void
clip_notify_duration_cb (GESClip * object,
clip_notify_duration_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app)
{
GtkTreeIter iter;
guint64 duration = 0;
g_object_get (object, "duration", &duration, NULL);
find_row_for_object (app->model, &iter, object);
g_object_get (clip, "duration", &duration, NULL);
find_row_for_object (app->model, &iter, clip);
gtk_list_store_set (app->model, &iter, 1, duration, -1);
}
@ -266,37 +266,37 @@ clip_notify_duration_cb (GESClip * object,
* current selection */
static void
filesource_notify_duration_cb (GESClip * object,
filesource_notify_duration_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app)
{
guint64 duration, max_inpoint;
duration = GES_TIMELINE_ELEMENT_DURATION (object);
max_inpoint = GES_TIMELINE_ELEMENT_MAX_DURATION (object) - duration;
duration = GES_TIMELINE_ELEMENT_DURATION (clip);
max_inpoint = GES_TIMELINE_ELEMENT_MAX_DURATION (clip) - duration;
gtk_range_set_value (GTK_RANGE (app->duration), duration);
gtk_range_set_fill_level (GTK_RANGE (app->in_point), max_inpoint);
if (max_inpoint < GES_TIMELINE_ELEMENT_INPOINT (object))
g_object_set (object, "in-point", max_inpoint, NULL);
if (max_inpoint < GES_TIMELINE_ELEMENT_INPOINT (clip))
g_object_set (clip, "in-point", max_inpoint, NULL);
}
static void
filesource_notify_max_duration_cb (GESClip * object,
filesource_notify_max_duration_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app)
{
gtk_range_set_range (GTK_RANGE (app->duration), 0, (gdouble)
GES_TIMELINE_ELEMENT_MAX_DURATION (object));
GES_TIMELINE_ELEMENT_MAX_DURATION (clip));
gtk_range_set_range (GTK_RANGE (app->in_point), 0, (gdouble)
GES_TIMELINE_ELEMENT_MAX_DURATION (object));
GES_TIMELINE_ELEMENT_MAX_DURATION (clip));
}
static void
filesource_notify_in_point_cb (GESClip * object,
filesource_notify_in_point_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app)
{
gtk_range_set_value (GTK_RANGE (app->in_point),
GES_TIMELINE_ELEMENT_INPOINT (object));
GES_TIMELINE_ELEMENT_INPOINT (clip));
}
static void
@ -325,66 +325,66 @@ object_count_changed (App * app)
}
static void
title_source_text_changed_cb (GESClip * object,
title_source_text_changed_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app)
{
GtkTreeIter iter;
gchar *text;
g_object_get (object, "text", &text, NULL);
g_object_get (clip, "text", &text, NULL);
if (text) {
find_row_for_object (app->model, &iter, object);
find_row_for_object (app->model, &iter, clip);
gtk_list_store_set (app->model, &iter, 0, text, -1);
}
}
static void
layer_object_added_cb (GESTimelineLayer * layer, GESClip * object, App * app)
layer_object_added_cb (GESTimelineLayer * layer, GESClip * clip, App * app)
{
GtkTreeIter iter;
gchar *description;
GST_INFO ("layer object added cb %p %p %p", layer, object, app);
GST_INFO ("layer clip added cb %p %p %p", layer, clip, app);
gtk_list_store_append (app->model, &iter);
if (GES_IS_URI_CLIP (object)) {
g_object_get (G_OBJECT (object), "uri", &description, NULL);
gtk_list_store_set (app->model, &iter, 0, description, 2, object, -1);
if (GES_IS_URI_CLIP (clip)) {
g_object_get (G_OBJECT (clip), "uri", &description, NULL);
gtk_list_store_set (app->model, &iter, 0, description, 2, clip, -1);
}
else if (GES_IS_TITLE_CLIP (object)) {
gtk_list_store_set (app->model, &iter, 2, object, -1);
g_signal_connect (G_OBJECT (object), "notify::text",
else if (GES_IS_TITLE_CLIP (clip)) {
gtk_list_store_set (app->model, &iter, 2, clip, -1);
g_signal_connect (G_OBJECT (clip), "notify::text",
G_CALLBACK (title_source_text_changed_cb), app);
title_source_text_changed_cb (object, NULL, app);
title_source_text_changed_cb (clip, NULL, app);
}
else if (GES_IS_TEST_CLIP (object)) {
gtk_list_store_set (app->model, &iter, 2, object, 0, "Test Source", -1);
else if (GES_IS_TEST_CLIP (clip)) {
gtk_list_store_set (app->model, &iter, 2, clip, 0, "Test Source", -1);
}
else if (GES_IS_BASE_TRANSITION_CLIP (object)) {
gtk_list_store_set (app->model, &iter, 2, object, 0, "Transition", -1);
else if (GES_IS_BASE_TRANSITION_CLIP (clip)) {
gtk_list_store_set (app->model, &iter, 2, clip, 0, "Transition", -1);
}
g_signal_connect (G_OBJECT (object), "notify::duration",
g_signal_connect (G_OBJECT (clip), "notify::duration",
G_CALLBACK (clip_notify_duration_cb), app);
clip_notify_duration_cb (object, NULL, app);
clip_notify_duration_cb (clip, NULL, app);
app->n_objects++;
object_count_changed (app);
}
static void
layer_object_removed_cb (GESTimelineLayer * layer, GESClip * object, App * app)
layer_object_removed_cb (GESTimelineLayer * layer, GESClip * clip, App * app)
{
GtkTreeIter iter;
GST_INFO ("layer object removed cb %p %p %p", layer, object, app);
GST_INFO ("layer clip removed cb %p %p %p", layer, clip, app);
if (!find_row_for_object (GTK_LIST_STORE (app->model), &iter, object)) {
g_print ("object deleted but we don't own it");
if (!find_row_for_object (GTK_LIST_STORE (app->model), &iter, clip)) {
g_print ("clip deleted but we don't own it");
return;
}
app->n_objects--;
@ -394,7 +394,7 @@ layer_object_removed_cb (GESTimelineLayer * layer, GESClip * object, App * app)
}
static void
layer_object_moved_cb (GESClip * layer, GESClip * object,
layer_object_moved_cb (GESClip * layer, GESClip * clip,
gint old, gint new, App * app)
{
GtkTreeIter a, b;
@ -592,62 +592,64 @@ duration_cell_func (GtkTreeViewColumn * column, GtkCellRenderer * renderer,
/* UI Initialization ********************************************************/
static void
connect_to_filesource (GESClip * object, App * app)
connect_to_filesource (GESClip * clip, App * app)
{
g_signal_connect (G_OBJECT (object), "notify::max-duration",
g_signal_connect (G_OBJECT (clip), "notify::max-duration",
G_CALLBACK (filesource_notify_max_duration_cb), app);
filesource_notify_max_duration_cb (object, NULL, app);
filesource_notify_max_duration_cb (clip, NULL, app);
g_signal_connect (G_OBJECT (object), "notify::duration",
g_signal_connect (G_OBJECT (clip), "notify::duration",
G_CALLBACK (filesource_notify_duration_cb), app);
filesource_notify_duration_cb (object, NULL, app);
filesource_notify_duration_cb (clip, NULL, app);
g_signal_connect (G_OBJECT (object), "notify::in-point",
g_signal_connect (G_OBJECT (clip), "notify::in-point",
G_CALLBACK (filesource_notify_in_point_cb), app);
filesource_notify_in_point_cb (object, NULL, app);
filesource_notify_in_point_cb (clip, NULL, app);
}
static void
disconnect_from_filesource (GESClip * object, App * app)
disconnect_from_filesource (GESClip * clip, App * app)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (object),
g_signal_handlers_disconnect_by_func (G_OBJECT (clip),
filesource_notify_duration_cb, app);
g_signal_handlers_disconnect_by_func (G_OBJECT (object),
g_signal_handlers_disconnect_by_func (G_OBJECT (clip),
filesource_notify_max_duration_cb, app);
}
static void
connect_to_title_source (GESClip * object, App * app)
connect_to_title_source (GESClip * clip, App * app)
{
GESTitleClip *obj;
obj = GES_TITLE_CLIP (object);
gtk_combo_box_set_active (app->halign, ges_title_clip_get_halignment (obj));
gtk_combo_box_set_active (app->valign, ges_title_clip_get_valignment (obj));
gtk_entry_set_text (app->text, ges_title_clip_get_text (obj));
GESTitleClip *titleclip;
titleclip = GES_TITLE_CLIP (clip);
gtk_combo_box_set_active (app->halign,
ges_title_clip_get_halignment (titleclip));
gtk_combo_box_set_active (app->valign,
ges_title_clip_get_valignment (titleclip));
gtk_entry_set_text (app->text, ges_title_clip_get_text (titleclip));
}
static void
disconnect_from_title_source (GESClip * object, App * app)
disconnect_from_title_source (GESClip * clip, App * app)
{
}
static void
connect_to_test_source (GESClip * object, App * app)
connect_to_test_source (GESClip * clip, App * app)
{
GObjectClass *klass;
GParamSpecDouble *pspec;
GESTestClip *obj;
obj = GES_TEST_CLIP (object);
GESTestClip *testclip;
testclip = GES_TEST_CLIP (clip);
gtk_combo_box_set_active (app->background_type,
ges_test_clip_get_vpattern (obj));
ges_test_clip_get_vpattern (testclip));
g_signal_connect (G_OBJECT (object), "notify::volume",
g_signal_connect (G_OBJECT (testclip), "notify::volume",
G_CALLBACK (test_source_notify_volume_changed_cb), app);
test_source_notify_volume_changed_cb (object, NULL, app);
test_source_notify_volume_changed_cb (clip, NULL, app);
klass = G_OBJECT_GET_CLASS (G_OBJECT (object));
klass = G_OBJECT_GET_CLASS (G_OBJECT (testclip));
pspec = G_PARAM_SPEC_DOUBLE (g_object_class_find_property (klass, "volume"));
gtk_range_set_range (GTK_RANGE (app->volume), pspec->minimum, pspec->maximum);
@ -655,49 +657,49 @@ connect_to_test_source (GESClip * object, App * app)
pspec = G_PARAM_SPEC_DOUBLE (g_object_class_find_property (klass, "freq"));
gtk_spin_button_set_range (app->frequency, pspec->minimum, pspec->maximum);
gtk_spin_button_set_value (app->frequency,
ges_test_clip_get_frequency (GES_TEST_CLIP (object)));
ges_test_clip_get_frequency (GES_TEST_CLIP (clip)));
}
static void
disconnect_from_test_source (GESClip * object, App * app)
disconnect_from_test_source (GESClip * clip, App * app)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (object),
g_signal_handlers_disconnect_by_func (G_OBJECT (clip),
test_source_notify_volume_changed_cb, app);
}
static void
connect_to_object (GESClip * object, App * app)
connect_to_object (GESClip * clip, App * app)
{
gchar buf[30];
guint64 duration;
app->ignore_input = TRUE;
duration = GES_TIMELINE_ELEMENT_DURATION (object);
duration = GES_TIMELINE_ELEMENT_DURATION (clip);
g_snprintf (buf, sizeof (buf), "%02u:%02u:%02u.%09u",
GST_TIME_ARGS (duration));
gtk_entry_set_text (app->seconds, buf);
if (GES_IS_URI_CLIP (object)) {
connect_to_filesource (object, app);
} else if (GES_IS_TITLE_CLIP (object)) {
connect_to_title_source (object, app);
} else if (GES_IS_TEST_CLIP (object)) {
connect_to_test_source (object, app);
if (GES_IS_URI_CLIP (clip)) {
connect_to_filesource (clip, app);
} else if (GES_IS_TITLE_CLIP (clip)) {
connect_to_title_source (clip, app);
} else if (GES_IS_TEST_CLIP (clip)) {
connect_to_test_source (clip, app);
}
app->ignore_input = FALSE;
}
static void
disconnect_from_object (GESClip * object, App * app)
disconnect_from_object (GESClip * clip, App * app)
{
if (GES_IS_URI_CLIP (object)) {
disconnect_from_filesource (object, app);
} else if (GES_IS_TITLE_CLIP (object)) {
disconnect_from_title_source (object, app);
} else if (GES_IS_TEST_CLIP (object)) {
disconnect_from_test_source (object, app);
if (GES_IS_URI_CLIP (clip)) {
disconnect_from_filesource (clip, app);
} else if (GES_IS_TITLE_CLIP (clip)) {
disconnect_from_title_source (clip, app);
} else if (GES_IS_TEST_CLIP (clip)) {
disconnect_from_test_source (clip, app);
}
}
@ -1018,10 +1020,10 @@ selection_foreach (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter
* iter, gpointer user)
{
select_info *info = (select_info *) user;
GESClip *obj;
GESClip *clip;
gtk_tree_model_get (model, iter, 2, &obj, -1);
info->objects = g_list_append (info->objects, obj);
gtk_tree_model_get (model, iter, 2, &clip, -1);
info->objects = g_list_append (info->objects, clip);
info->n++;
return;
@ -1144,14 +1146,14 @@ app_move_selected_down (App * app)
static void
app_add_file (App * app, gchar * uri)
{
GESClip *obj;
GESClip *clip;
GST_DEBUG ("adding file %s", uri);
obj = GES_CLIP (ges_uri_clip_new (uri));
clip = GES_CLIP (ges_uri_clip_new (uri));
ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER (app->layer),
obj, -1);
clip, -1);
}
static void
@ -1184,44 +1186,44 @@ app_launch_project (App * app, gchar * uri)
static void
app_add_title (App * app)
{
GESClip *obj;
GESClip *clip;
GST_DEBUG ("adding title");
obj = GES_CLIP (ges_title_clip_new ());
g_object_set (G_OBJECT (obj), "duration", GST_SECOND, NULL);
clip = GES_CLIP (ges_title_clip_new ());
g_object_set (G_OBJECT (clip), "duration", GST_SECOND, NULL);
ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER (app->layer),
obj, -1);
clip, -1);
}
static void
app_add_test (App * app)
{
GESClip *obj;
GESClip *clip;
GST_DEBUG ("adding test");
obj = GES_CLIP (ges_test_clip_new ());
g_object_set (G_OBJECT (obj), "duration", GST_SECOND, NULL);
clip = GES_CLIP (ges_test_clip_new ());
g_object_set (G_OBJECT (clip), "duration", GST_SECOND, NULL);
ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER
(app->layer), obj, -1);
(app->layer), clip, -1);
}
static void
app_add_transition (App * app)
{
GESClip *obj;
GESClip *clip;
GST_DEBUG ("adding transition");
obj = GES_CLIP (ges_transition_clip_new
clip = GES_CLIP (ges_transition_clip_new
(GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE));
g_object_set (G_OBJECT (obj), "duration", GST_SECOND, NULL);
g_object_set (G_OBJECT (clip), "duration", GST_SECOND, NULL);
ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER
(app->layer), obj, -1);
(app->layer), clip, -1);
}
static void

24
tools/ges-launch.c
View file

@ -153,20 +153,20 @@ create_timeline (int nbargs, gchar ** argv, gchar * audio, gchar * video)
* ready to start using it... by solely working with the layer !*/
for (i = 0; i < nbargs / 3; i++) {
GESClip *obj;
GESClip *clip;
char *source = argv[i * 3];
char *arg0 = argv[(i * 3) + 1];
guint64 duration = str_to_time (argv[(i * 3) + 2]);
if (!g_strcmp0 ("+pattern", source)) {
obj = GES_CLIP (ges_test_clip_new_for_nick (arg0));
if (!obj) {
clip = GES_CLIP (ges_test_clip_new_for_nick (arg0));
if (!clip) {
g_error ("%s is an invalid pattern name!\n", arg0);
goto build_failure;
}
g_object_set (G_OBJECT (obj), "duration", duration, NULL);
g_object_set (G_OBJECT (clip), "duration", duration, NULL);
g_printf ("Adding <pattern:%s> duration %" GST_TIME_FORMAT "\n", arg0,
GST_TIME_ARGS (duration));
@ -178,14 +178,14 @@ create_timeline (int nbargs, gchar ** argv, gchar * audio, gchar * video)
goto build_failure;
}
obj = GES_CLIP (ges_transition_clip_new_for_nick (arg0));
clip = GES_CLIP (ges_transition_clip_new_for_nick (arg0));
if (!obj) {
if (!clip) {
g_error ("invalid transition type\n");
goto build_failure;
}
g_object_set (G_OBJECT (obj), "duration", duration, NULL);
g_object_set (G_OBJECT (clip), "duration", duration, NULL);
g_printf ("Adding <transition:%s> duration %" GST_TIME_FORMAT "\n", arg0,
GST_TIME_ARGS (duration));
@ -193,9 +193,9 @@ create_timeline (int nbargs, gchar ** argv, gchar * audio, gchar * video)
}
else if (!g_strcmp0 ("+title", source)) {
obj = GES_CLIP (ges_title_clip_new ());
clip = GES_CLIP (ges_title_clip_new ());
g_object_set (obj, "duration", duration, "text", arg0, NULL);
g_object_set (clip, "duration", duration, "text", arg0, NULL);
g_printf ("Adding <title:%s> duration %" GST_TIME_FORMAT "\n", arg0,
GST_TIME_ARGS (duration));
@ -211,8 +211,8 @@ create_timeline (int nbargs, gchar ** argv, gchar * audio, gchar * video)
}
inpoint = str_to_time (argv[i * 3 + 1]);
obj = GES_CLIP (ges_uri_clip_new (uri));
g_object_set (obj,
clip = GES_CLIP (ges_uri_clip_new (uri));
g_object_set (clip,
"in-point", (guint64) inpoint, "duration", (guint64) duration, NULL);
g_printf ("Adding clip %s inpoint:%" GST_TIME_FORMAT " duration:%"
@ -224,7 +224,7 @@ create_timeline (int nbargs, gchar ** argv, gchar * audio, gchar * video)
/* Since we're using a GESSimpleTimelineLayer, objects will be automatically
* appended to the end of the layer */
ges_timeline_layer_add_clip (layer, obj);
ges_timeline_layer_add_clip (layer, clip);
}
return timeline;