mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-03-30 12:49:40 +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 * static GstElement *
ges_audio_transition_create_element (GESTrackElement * object) ges_audio_transition_create_element (GESTrackElement * track_element)
{ {
GESAudioTransition *self; GESAudioTransition *self;
GstElement *topbin, *iconva, *iconvb, *oconv; 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; GstPad *sinka_target, *sinkb_target, *src_target, *sinka, *sinkb, *src;
GstControlSource *acontrol_source, *bcontrol_source; GstControlSource *acontrol_source, *bcontrol_source;
self = GES_AUDIO_TRANSITION (object); self = GES_AUDIO_TRANSITION (track_element);
GST_LOG ("creating an audio bin"); GST_LOG ("creating an audio bin");
@ -228,14 +228,14 @@ ges_audio_transition_create_element (GESTrackElement * object)
} }
static void static void
ges_audio_transition_duration_changed (GESTrackElement * object, ges_audio_transition_duration_changed (GESTrackElement * track_element,
guint64 duration) guint64 duration)
{ {
GESAudioTransition *self; GESAudioTransition *self;
GstElement *gnlobj = ges_track_element_get_gnlobject (object); GstElement *gnlobj = ges_track_element_get_gnlobject (track_element);
GstTimedValueControlSource *ta, *tb; GstTimedValueControlSource *ta, *tb;
self = GES_AUDIO_TRANSITION (object); self = GES_AUDIO_TRANSITION (track_element);
GST_LOG ("updating controller: gnlobj (%p)", gnlobj); 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); G_DEFINE_TYPE (GESAutoTransition, ges_auto_transition, G_TYPE_OBJECT);
static void static void
neighbour_changed_cb (GESClip * obj, GParamSpec * arg G_GNUC_UNUSED, neighbour_changed_cb (GESClip * clip, GParamSpec * arg G_GNUC_UNUSED,
GESAutoTransition * self) GESAutoTransition * self)
{ {
gint64 new_duration; gint64 new_duration;
@ -67,7 +67,7 @@ neighbour_changed_cb (GESClip * obj, GParamSpec * arg G_GNUC_UNUSED,
} }
static void static void
_height_changed_cb (GESClip * obj, GParamSpec * arg G_GNUC_UNUSED, _height_changed_cb (GESClip * clip, GParamSpec * arg G_GNUC_UNUSED,
GESAutoTransition * self) GESAutoTransition * self)
{ {
/* FIXME This is really not smart and we should properly implement clip /* 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 static void
_track_changed_cb (GESTrackElement * obj, GParamSpec * arg G_GNUC_UNUSED, _track_changed_cb (GESTrackElement * track_element,
GESAutoTransition * self) 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 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); 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) const gchar * metadatas, GError ** error)
{ {
GESAsset *asset; GESAsset *asset;
GESClip *nobj; GESClip *nclip;
LayerEntry *entry; LayerEntry *entry;
GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self); GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self);
@ -742,11 +742,11 @@ ges_base_xml_formatter_add_clip (GESBaseXmlFormatter * self,
return; 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, asset, start, inpoint, duration, rate, track_types, metadatas,
properties); properties);
if (!nobj) if (!nclip)
return; 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: * GESFillTrackElementFunc:
* @object: the #GESClip controlling the track elements * @clip: the #GESClip controlling the track elements
* @trobject: the #GESTrackElement * @track_element: the #GESTrackElement
* @gnlobj: the GNonLin object that needs to be filled. * @gnlobj: the GNonLin object that needs to be filled.
* *
* A function that will be called when the GNonLin object of a corresponding * 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. * Returns: TRUE if the implementer succesfully filled the @gnlobj, else #FALSE.
*/ */
typedef gboolean (*GESFillTrackElementFunc) (GESClip *object, typedef gboolean (*GESFillTrackElementFunc) (GESClip *clip,
GESTrackElement *trobject, GESTrackElement *track_element,
GstElement *gnlobj); GstElement *gnlobj);
/** /**
* GESCreateTrackElementFunc: * GESCreateTrackElementFunc:
* @object: a #GESClip * @clip: a #GESClip
* @type: a #GESTrackType * @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 * Subclasses should implement this method if they only provide a
* single #GESTrackElement per track. * single #GESTrackElement per track.
@ -71,7 +71,7 @@ typedef gboolean (*GESFillTrackElementFunc) (GESClip *object,
* method instead. * method instead.
* *
* The implementer of this function shall return the proper #GESTrackElement * 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 * The returned #GESTrackElement will be automatically added to the list
* of objects controlled by the #GESClip. * 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 * Returns: the #GESTrackElement to be used, or %NULL if it can't provide one
* for the given @track. * for the given @track.
*/ */
typedef GESTrackElement *(*GESCreateTrackElementFunc) (GESClip * object, typedef GESTrackElement *(*GESCreateTrackElementFunc) (GESClip * clip,
GESTrackType type); GESTrackType type);
/** /**
* GESCreateTrackElementsFunc: * GESCreateTrackElementsFunc:
* @object: a #GESClip * @clip: a #GESClip
* @type: a #GESTrackType * @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 * Subclasses should implement this method if they potentially need to
* return more than one #GESTrackElement(s) for a given #GESTrack. * return more than one #GESTrackElement(s) for a given #GESTrack.
* *
* For each object created, the subclass must call * For each clip created, the subclass must call
* ges_clip_add_track_element() with the newly created object * ges_clip_add_track_element() with the newly created clip
* and provided @type. * and provided @type.
* *
* Returns: %TRUE on success %FALSE on failure. * Returns: %TRUE on success %FALSE on failure.
*/ */
typedef GList * (*GESCreateTrackElementsFunc) (GESClip * object, GESTrackType type); typedef GList * (*GESCreateTrackElementsFunc) (GESClip * clip, GESTrackType type);
/** /**
* GES_CLIP_HEIGHT: * GES_CLIP_HEIGHT:
* @obj: a #GESClip * @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) #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 /* We don't add those properties to the priv struct for optimization purposes
* start, inpoint, duration and fullduration are in nanoseconds */ * start, inpoint, duration and fullduration are in nanoseconds */
guint32 height; /* the span of priorities this object needs */ guint32 height; /* the span of priorities this clip needs */
guint64 fullduration; /* Full usable duration of the object (-1: no duration) */ guint64 fullduration; /* Full usable duration of the clip (-1: no duration) */
/*< private >*/ /*< private >*/
GESClipPrivate *priv; GESClipPrivate *priv;
@ -166,9 +166,9 @@ struct _GESClipClass
gboolean need_fill_track; gboolean need_fill_track;
gboolean snaps; gboolean snaps;
void (*track_element_added) (GESClip *object, void (*track_element_added) (GESClip *clip,
GESTrackElement *track_element); GESTrackElement *track_element);
void (*track_element_released) (GESClip *object, void (*track_element_released) (GESClip *clip,
GESTrackElement *track_element); GESTrackElement *track_element);
/*< private >*/ /*< private >*/
@ -179,37 +179,37 @@ struct _GESClipClass
GType ges_clip_get_type (void); GType ges_clip_get_type (void);
/* Setters */ /* Setters */
void ges_clip_set_layer (GESClip *object, void ges_clip_set_layer (GESClip *clip,
GESTimelineLayer *layer); GESTimelineLayer *layer);
/* TrackElement handling */ /* TrackElement handling */
GList* ges_clip_get_track_elements (GESClip *object); GList* ges_clip_get_track_elements (GESClip *clip);
GESTrackType ges_clip_get_supported_formats (GESClip *object); GESTrackType ges_clip_get_supported_formats (GESClip *clip);
GESTrackElement *ges_clip_create_track_element (GESClip *object, GESTrackType type); GESTrackElement *ges_clip_create_track_element (GESClip *clip, GESTrackType type);
GList * ges_clip_create_track_elements (GESClip *object, GESTrackType type); GList * ges_clip_create_track_elements (GESClip *clip, GESTrackType type);
gboolean ges_clip_release_track_element (GESClip *object, GESTrackElement *trackelement); gboolean ges_clip_release_track_element (GESClip *clip, GESTrackElement *trackelement);
void ges_clip_set_supported_formats (GESClip *object, GESTrackType supportedformats); void ges_clip_set_supported_formats (GESClip *clip, GESTrackType supportedformats);
gboolean ges_clip_add_asset (GESClip *object, GESAsset *asset); gboolean ges_clip_add_asset (GESClip *clip, GESAsset *asset);
gboolean ges_clip_add_track_element (GESClip *object, GESTrackElement *trobj); gboolean ges_clip_add_track_element (GESClip *clip, GESTrackElement *track_element);
gboolean ges_clip_fill_track_element (GESClip *object, GESTrackElement *trackelement, GstElement *gnlobj); gboolean ges_clip_fill_track_element (GESClip *clip, GESTrackElement *trackelement, GstElement *gnlobj);
GESTrackElement *ges_clip_find_track_element (GESClip *object, GESTrack *track, GType type); GESTrackElement *ges_clip_find_track_element (GESClip *clip, GESTrack *track, GType type);
/* Layer */ /* Layer */
GESTimelineLayer *ges_clip_get_layer (GESClip *object); GESTimelineLayer *ges_clip_get_layer (GESClip *clip);
gboolean ges_clip_is_moving_from_layer (GESClip *object); gboolean ges_clip_is_moving_from_layer (GESClip *clip);
gboolean ges_clip_move_to_layer (GESClip *object, GESTimelineLayer *layer); gboolean ges_clip_move_to_layer (GESClip *clip, GESTimelineLayer *layer);
void ges_clip_set_moving_from_layer (GESClip *object, gboolean is_moving); void ges_clip_set_moving_from_layer (GESClip *clip, gboolean is_moving);
/* Effects */ /* Effects */
GList* ges_clip_get_top_effects (GESClip *object); GList* ges_clip_get_top_effects (GESClip *clip);
gint ges_clip_get_top_effect_position (GESClip *object, GESBaseEffect *effect); gint ges_clip_get_top_effect_position (GESClip *clip, GESBaseEffect *effect);
gboolean ges_clip_set_top_effect_priority (GESClip *object, GESBaseEffect *effect, guint newpriority); gboolean ges_clip_set_top_effect_priority (GESClip *clip, GESBaseEffect *effect, guint newpriority);
/* Editing */ /* Editing */
GESClip *ges_clip_split (GESClip *object, guint64 position); GESClip *ges_clip_split (GESClip *clip, guint64 position);
void ges_clip_objects_set_locked (GESClip *object, gboolean locked); 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, gint new_layer_priority, GESEditMode mode,
GESEdge edge, guint64 position); 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 static gboolean
ges_custom_source_clip_fill_track_element (GESClip * object, ges_custom_source_clip_fill_track_element (GESClip * clip,
GESTrackElement * trobject, GstElement * gnlobj); GESTrackElement * track_element, GstElement * gnlobj);
static GESTrackElement * 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); return g_object_new (GES_TYPE_SOURCE, "track-type", type, NULL);
} }
@ -199,17 +199,18 @@ ges_custom_source_clip_init (GESCustomSourceClip * self)
} }
static gboolean static gboolean
ges_custom_source_clip_fill_track_element (GESClip * object, ges_custom_source_clip_fill_track_element (GESClip * clip,
GESTrackElement * trobject, GstElement * gnlobj) GESTrackElement * track_element, GstElement * gnlobj)
{ {
gboolean res; gboolean res;
GESCustomSourceClipPrivate *priv; GESCustomSourceClipPrivate *priv;
GST_DEBUG ("Calling callback (timelineobj:%p, trackelement:%p, gnlobj:%p)", GST_DEBUG ("Calling callback (timelineobj:%p, trackelement:%p, gnlobj:%p)",
object, trobject, gnlobj); clip, track_element, gnlobj);
priv = GES_CUSTOM_SOURCE_CLIP (object)->priv; priv = GES_CUSTOM_SOURCE_CLIP (clip)->priv;
res = priv->filltrackelementfunc (object, trobject, gnlobj, priv->user_data); res = priv->filltrackelementfunc (clip, track_element, gnlobj,
priv->user_data);
GST_DEBUG ("Returning res:%d", res); GST_DEBUG ("Returning res:%d", res);

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

@ -49,7 +49,7 @@ typedef struct _GESCustomSourceClipPrivate GESCustomSourceClipPrivate;
/** /**
* GESFillTrackElementUserFunc: * GESFillTrackElementUserFunc:
* @object: the #GESClip controlling the track element * @object: the #GESClip controlling the track element
* @trobject: the #GESTrackElement * @track_element: the #GESTrackElement
* @gnlobj: the GNonLin object that needs to be filled. * @gnlobj: the GNonLin object that needs to be filled.
* @user_data: the gpointer to optional user data * @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. * Returns: TRUE if the implementer succesfully filled the @gnlobj, else #FALSE.
*/ */
typedef gboolean (*GESFillTrackElementUserFunc) (GESClip * object, typedef gboolean (*GESFillTrackElementUserFunc) (GESClip * object,
GESTrackElement * trobject, GESTrackElement * track_element,
GstElement * gnlobj, GstElement * gnlobj,
gpointer user_data); 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 * static GstElement *
ges_image_source_create_element (GESTrackElement * object) ges_image_source_create_element (GESTrackElement * track_element)
{ {
GstElement *bin, *source, *scale, *freeze, *iconv; GstElement *bin, *source, *scale, *freeze, *iconv;
GstPad *src, *target; GstPad *src, *target;
@ -138,7 +138,7 @@ ges_image_source_create_element (GESTrackElement * object)
gst_element_add_pad (bin, src); gst_element_add_pad (bin, src);
gst_object_unref (target); 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_signal_connect (G_OBJECT (source), "pad-added",
G_CALLBACK (pad_added_cb), scale); 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 typedef struct SrcMapping
{ {
gchar *id; gchar *id;
GESClip *obj; GESClip *clip;
guint priority; guint priority;
GList *track_element_ids; GList *track_element_ids;
} SrcMapping; } SrcMapping;
@ -96,7 +96,7 @@ static void
free_src_map (SrcMapping * srcmap) free_src_map (SrcMapping * srcmap)
{ {
g_free (srcmap->id); 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_foreach (srcmap->track_element_ids, (GFunc) g_free, NULL);
g_list_free (srcmap->track_element_ids); g_list_free (srcmap->track_element_ids);
g_slice_free (SrcMapping, srcmap); g_slice_free (SrcMapping, srcmap);
@ -158,15 +158,15 @@ save_track_elements (xmlTextWriterPtr writer, GList * source_list,
GST_DEBUG ("Saving track elements"); GST_DEBUG ("Saving track elements");
for (tmp = source_list; tmp; tmp = tmp->next) { for (tmp = source_list; tmp; tmp = tmp->next) {
SrcMapping *srcmap; SrcMapping *srcmap;
GESClip *object; GESClip *clip;
guint i, j; guint i, j;
guint64 inpoint, duration, start; guint64 inpoint, duration, start;
srcmap = (SrcMapping *) tmp->data; srcmap = (SrcMapping *) tmp->data;
object = srcmap->obj; clip = srcmap->clip;
/* Save track associated objects */ /* 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) { for (tmp_tck = track_elements; tmp_tck; tmp_tck = tmp_tck->next) {
xmlChar *cast; xmlChar *cast;
GESTrackElement *trackelement = GES_TRACK_ELEMENT (tmp_tck->data); GESTrackElement *trackelement = GES_TRACK_ELEMENT (tmp_tck->data);
@ -388,7 +388,7 @@ save_sources (GESPitiviFormatter * formatter, GList * layers,
srcmap->id = srcmap->id =
g_strdup (g_hash_table_lookup (priv->saving_source_table, g_strdup (g_hash_table_lookup (priv->saving_source_table,
uriclip_uri)); uriclip_uri));
srcmap->obj = g_object_ref (clip); srcmap->clip = g_object_ref (clip);
srcmap->priority = ges_timeline_layer_get_priority (layer); srcmap->priority = ges_timeline_layer_get_priority (layer);
/* We fill up the track_element_ids in save_track_elements */ /* We fill up the track_element_ids in save_track_elements */
source_list = g_list_append (source_list, srcmap); source_list = g_list_append (source_list, srcmap);
@ -748,7 +748,7 @@ set_properties (GObject * obj, GHashTable * props_table)
} }
static void static void
track_element_added_cb (GESClip * object, track_element_added_cb (GESClip * clip,
GESTrackElement * track_element, GHashTable * props_table) GESTrackElement * track_element, GHashTable * props_table)
{ {
gchar *media_type = NULL, *lockedstr; gchar *media_type = NULL, *lockedstr;
@ -759,7 +759,7 @@ track_element_added_cb (GESClip * object,
gint type = 0; gint type = 0;
GESPitiviFormatter *formatter; 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"); media_type = (gchar *) g_hash_table_lookup (props_table, "media_type");
lockedstr = (gchar *) g_hash_table_lookup (props_table, "locked"); lockedstr = (gchar *) g_hash_table_lookup (props_table, "locked");
@ -773,7 +773,7 @@ track_element_added_cb (GESClip * object,
* doesn't break everything */ * doesn't break everything */
g_hash_table_steal (props_table, "current-formatter"); 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) if (!priv->sources_to_load && GES_FORMATTER (formatter)->project)
ges_project_set_loaded (GES_FORMATTER (formatter)->project, ges_project_set_loaded (GES_FORMATTER (formatter)->project,
GES_FORMATTER (formatter)); GES_FORMATTER (formatter));
@ -819,7 +819,7 @@ track_element_added_cb (GESClip * object,
} }
if (has_effect) { 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 /* FIXME make sure this is the way we want to handle that
* ie: set duration and start as the other trackelement * ie: set duration and start as the other trackelement
@ -841,7 +841,7 @@ track_element_added_cb (GESClip * object,
} }
/* Disconnect the signal */ /* 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); props_table);
} }

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

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

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

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

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

@ -64,7 +64,7 @@ enum
}; };
static GESTrackElement static GESTrackElement
* ges_text_overlay_clip_create_track_element (GESClip * obj, * ges_text_overlay_clip_create_track_element (GESClip * clip,
GESTrackType type); GESTrackType type);
static void static void
@ -267,7 +267,7 @@ void
ges_text_overlay_clip_set_text (GESTextOverlayClip * self, const gchar * text) ges_text_overlay_clip_set_text (GESTextOverlayClip * self, const gchar * text)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, text:%s", self, text); 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); 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -303,7 +303,7 @@ ges_text_overlay_clip_set_font_desc (GESTextOverlayClip * self,
const gchar * font_desc) const gchar * font_desc)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, font_desc:%s", self, font_desc); 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); 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -340,13 +340,13 @@ ges_text_overlay_clip_set_halign (GESTextOverlayClip * self,
GESTextHAlign halign) GESTextHAlign halign)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, halign:%d", self, halign); GST_DEBUG ("self:%p, halign:%d", self, halign);
self->priv->halign = 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -374,13 +374,13 @@ ges_text_overlay_clip_set_valign (GESTextOverlayClip * self,
GESTextVAlign valign) GESTextVAlign valign)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, valign:%d", self, valign); GST_DEBUG ("self:%p, valign:%d", self, valign);
self->priv->valign = 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -408,13 +408,13 @@ void
ges_text_overlay_clip_set_color (GESTextOverlayClip * self, guint32 color) ges_text_overlay_clip_set_color (GESTextOverlayClip * self, guint32 color)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, color:%d", self, color); GST_DEBUG ("self:%p, color:%d", self, color);
self->priv->color = 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -441,13 +441,13 @@ void
ges_text_overlay_clip_set_xpos (GESTextOverlayClip * self, gdouble position) ges_text_overlay_clip_set_xpos (GESTextOverlayClip * self, gdouble position)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, xpos:%f", self, position); GST_DEBUG ("self:%p, xpos:%f", self, position);
self->priv->xpos = 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -474,13 +474,13 @@ void
ges_text_overlay_clip_set_ypos (GESTextOverlayClip * self, gdouble position) ges_text_overlay_clip_set_ypos (GESTextOverlayClip * self, gdouble position)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, ypos:%f", self, position); GST_DEBUG ("self:%p, ypos:%f", self, position);
self->priv->ypos = 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -603,10 +603,10 @@ ges_text_overlay_clip_get_ypos (GESTextOverlayClip * self)
} }
static GESTrackElement * 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; GESTrackElement *res = NULL;
GST_DEBUG ("Creating a GESTrackOverlay"); 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 * static GstElement *
ges_text_overlay_create_element (GESTrackElement * object) ges_text_overlay_create_element (GESTrackElement * track_element)
{ {
GstElement *ret, *text, *iconv, *oconv; GstElement *ret, *text, *iconv, *oconv;
GstPad *src_target, *sink_target; GstPad *src_target, *sink_target;
GstPad *src, *sink; GstPad *src, *sink;
GESTextOverlay *self = GES_TEXT_OVERLAY (object); GESTextOverlay *self = GES_TEXT_OVERLAY (track_element);
text = gst_element_factory_make ("textoverlay", NULL); text = gst_element_factory_make ("textoverlay", NULL);
iconv = gst_element_factory_make ("videoconvert", 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 struct _GESTimelineLayerPrivate
{ {
/*< private > */ /*< private > */
GList *objects_start; /* The Clips sorted by start and GList *clips_start; /* The Clips sorted by start and
* priority */ * priority */
guint32 priority; /* The priority of the layer within the guint32 priority; /* The priority of the layer within the
@ -56,7 +56,7 @@ struct _GESTimelineLayerPrivate
typedef struct typedef struct
{ {
GESClip *object; GESClip *clip;
GESTimelineLayer *layer; GESTimelineLayer *layer;
} NewAssetUData; } NewAssetUData;
@ -123,9 +123,8 @@ ges_timeline_layer_dispose (GObject * object)
GST_DEBUG ("Disposing layer"); GST_DEBUG ("Disposing layer");
while (priv->objects_start) while (priv->clips_start)
ges_timeline_layer_remove_clip (layer, ges_timeline_layer_remove_clip (layer, (GESClip *) priv->clips_start->data);
(GESClip *) priv->objects_start->data);
G_OBJECT_CLASS (ges_timeline_layer_parent_class)->dispose (object); G_OBJECT_CLASS (ges_timeline_layer_parent_class)->dispose (object);
} }
@ -171,9 +170,9 @@ ges_timeline_layer_class_init (GESTimelineLayerClass * klass)
/** /**
* GESTimelineLayer::clip-added: * GESTimelineLayer::clip-added:
* @layer: the #GESTimelineLayer * @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] = ges_timeline_layer_signals[OBJECT_ADDED] =
g_signal_new ("clip-added", G_TYPE_FROM_CLASS (klass), g_signal_new ("clip-added", G_TYPE_FROM_CLASS (klass),
@ -183,9 +182,9 @@ ges_timeline_layer_class_init (GESTimelineLayerClass * klass)
/** /**
* GESTimelineLayer::clip-removed: * GESTimelineLayer::clip-removed:
* @layer: the #GESTimelineLayer * @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] = ges_timeline_layer_signals[OBJECT_REMOVED] =
g_signal_new ("clip-removed", G_TYPE_FROM_CLASS (klass), g_signal_new ("clip-removed", G_TYPE_FROM_CLASS (klass),
@ -217,7 +216,7 @@ static gboolean
ges_timeline_layer_resync_priorities (GESTimelineLayer * layer) ges_timeline_layer_resync_priorities (GESTimelineLayer * layer)
{ {
GList *tmp; GList *tmp;
GESTimelineElement *obj; GESTimelineElement *track_element;
GST_DEBUG ("Resync priorities of %p", layer); 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 * Ideally we want to do it from an even higher level, but here will
* do in the meantime. */ * do in the meantime. */
for (tmp = layer->priv->objects_start; tmp; tmp = tmp->next) { for (tmp = layer->priv->clips_start; tmp; tmp = tmp->next) {
obj = GES_TIMELINE_ELEMENT (tmp->data); track_element = GES_TIMELINE_ELEMENT (tmp->data);
_set_priority0 (obj, _PRIORITY (obj)); _set_priority0 (track_element, _PRIORITY (track_element));
} }
return TRUE; return TRUE;
@ -241,7 +240,7 @@ new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata)
GESAsset *asset = ges_asset_request_finish (res, &error); GESAsset *asset = ges_asset_request_finish (res, &error);
GST_DEBUG_OBJECT (udata->layer, "%" GST_PTR_FORMAT " Asset loaded, " GST_DEBUG_OBJECT (udata->layer, "%" GST_PTR_FORMAT " Asset loaded, "
"setting its asset", udata->object); "setting its asset", udata->clip);
if (error) { if (error) {
GESProject *project = udata->layer->timeline ? GESProject *project = udata->layer->timeline ?
@ -266,10 +265,10 @@ new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata)
GESProject *project = udata->layer->timeline ? GESProject *project = udata->layer->timeline ?
GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE
(udata->layer->timeline))) : NULL; (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_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); g_object_unref (asset);
@ -280,27 +279,27 @@ new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata)
/** /**
* ges_timeline_layer_remove_clip: * ges_timeline_layer_remove_clip:
* @layer: a #GESTimelineLayer * @layer: a #GESTimelineLayer
* @object: the #GESClip to remove * @clip: the #GESClip to remove
* *
* Removes the given @object from the @layer and unparents it. * Removes the given @clip from the @layer and unparents it.
* Unparenting it means the reference owned by @layer on the @object will be * Unparenting it means the reference owned by @layer on the @clip will be
* removed. If you wish to use the @object after this function, make sure you * removed. If you wish to use the @clip after this function, make sure you
* call g_object_ref() before removing it from the @layer. * call g_object_ref() before removing it from the @layer.
* *
* Returns: TRUE if the object could be removed, FALSE if the layer does * Returns: TRUE if the clip could be removed, FALSE if the layer does
* not want to remove the object. * not want to remove the clip.
*/ */
gboolean gboolean
ges_timeline_layer_remove_clip (GESTimelineLayer * layer, GESClip * object) ges_timeline_layer_remove_clip (GESTimelineLayer * layer, GESClip * clip)
{ {
GESTimelineLayer *current_layer; GESTimelineLayer *current_layer;
g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), FALSE); 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)) { if (G_UNLIKELY (current_layer != layer)) {
GST_WARNING ("Clip doesn't belong to this 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); g_object_unref (current_layer);
/* emit 'clip-removed' */ /* 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 */ /* inform the clip it's no longer in a layer */
ges_clip_set_layer (object, NULL); ges_clip_set_layer (clip, NULL);
/* Remove it from our list of controlled objects */ /* Remove it from our list of controlled objects */
layer->priv->objects_start = layer->priv->clips_start = g_list_remove (layer->priv->clips_start, clip);
g_list_remove (layer->priv->objects_start, object);
/* Remove our reference to the object */ /* Remove our reference to the clip */
g_object_unref (object); g_object_unref (clip);
return TRUE; return TRUE;
} }
@ -427,7 +425,7 @@ ges_timeline_layer_get_clips (GESTimelineLayer * layer)
return klass->get_objects (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), (GCopyFunc) gst_object_ref, NULL),
(GCompareFunc) element_start_compare); (GCompareFunc) element_start_compare);
} }
@ -436,7 +434,7 @@ ges_timeline_layer_get_clips (GESTimelineLayer * layer)
* ges_timeline_layer_is_empty: * ges_timeline_layer_is_empty:
* @layer: The #GESTimelineLayer to check * @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. * or not.
* *
* Returns: %TRUE if @layer is empty, %FALSE if it already contains at least * 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); 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: * ges_timeline_layer_add_clip:
* @layer: a #GESTimelineLayer * @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 * Adds the given clip to the layer. Sets the clip's parent, and thus
* takes ownership of the object. * 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 * 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) * elements on @clip. If you need to know when those objects (actually #GESTrackElement)
* are constructed, you should connect to the object::track-element-added signal which * are constructed, you should connect to the clip::track-element-added signal which
* is emited right after those elements are ready to be used. * is emited right after those elements are ready to be used.
* *
* Returns: TRUE if the object was properly added to the layer, or FALSE * Returns: TRUE if the clip was properly added to the layer, or FALSE
* if the @layer refuses to add the object. * if the @layer refuses to add the clip.
*/ */
gboolean gboolean
ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * object) ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * clip)
{ {
GESAsset *asset; GESAsset *asset;
GESTimelineLayerPrivate *priv; GESTimelineLayerPrivate *priv;
@ -477,42 +475,42 @@ ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * object)
guint32 maxprio, minprio, prio; guint32 maxprio, minprio, prio;
g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), FALSE); 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; priv = layer->priv;
current_layer = ges_clip_get_layer (object); current_layer = ges_clip_get_layer (clip);
if (G_UNLIKELY (current_layer)) { 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); g_object_unref (current_layer);
return FALSE; return FALSE;
} }
asset = ges_extractable_get_asset (GES_EXTRACTABLE (object)); asset = ges_extractable_get_asset (GES_EXTRACTABLE (clip));
if (asset == NULL) { if (asset == NULL) {
gchar *id; gchar *id;
NewAssetUData *mudata = g_slice_new (NewAssetUData); NewAssetUData *mudata = g_slice_new (NewAssetUData);
mudata->object = object; mudata->clip = clip;
mudata->layer = layer; mudata->layer = layer;
GST_DEBUG_OBJECT (layer, "%" GST_PTR_FORMAT " as no reference to any " 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)); id = ges_extractable_get_id (GES_EXTRACTABLE (clip));
asset = ges_asset_request (G_OBJECT_TYPE (object), id, NULL); asset = ges_asset_request (G_OBJECT_TYPE (clip), id, NULL);
if (asset == NULL) { if (asset == NULL) {
GESProject *project = layer->timeline ? GESProject *project = layer->timeline ?
GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE
(layer->timeline))) : NULL; (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); id, NULL, (GAsyncReadyCallback) new_asset_cb, mudata);
if (project) 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); g_free (id);
GST_LOG_OBJECT (layer, "Object added async"); GST_LOG_OBJECT (layer, "Object added async");
@ -520,43 +518,43 @@ ges_timeline_layer_add_clip (GESTimelineLayer * layer, GESClip * object)
} }
g_free (id); 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_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 */ /* Take a reference to the clip and store it stored by start/priority */
priv->objects_start = g_list_insert_sorted (priv->objects_start, object, priv->clips_start = g_list_insert_sorted (priv->clips_start, clip,
(GCompareFunc) element_start_compare); (GCompareFunc) element_start_compare);
/* Inform the object it's now in this layer */ /* Inform the clip it's now in this layer */
ges_clip_set_layer (object, layer); ges_clip_set_layer (clip, layer);
GST_DEBUG ("current object priority : %d, layer min/max : %d/%d", GST_DEBUG ("current clip priority : %d, layer min/max : %d/%d",
_PRIORITY (object), layer->min_gnl_priority, layer->max_gnl_priority); _PRIORITY (clip), layer->min_gnl_priority, layer->max_gnl_priority);
/* Set the priority. */ /* Set the priority. */
maxprio = layer->max_gnl_priority; maxprio = layer->max_gnl_priority;
minprio = layer->min_gnl_priority; minprio = layer->min_gnl_priority;
prio = _PRIORITY (object); prio = _PRIORITY (clip);
if (minprio + prio > (maxprio)) { if (minprio + prio > (maxprio)) {
GST_WARNING_OBJECT (layer, GST_WARNING_OBJECT (layer,
"%p is out of the layer space, setting its priority to " "%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); 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 */ * priority */
ges_timeline_layer_resync_priorities (layer); ges_timeline_layer_resync_priorities (layer);
/* emit 'clip-added' */ /* 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; return TRUE;
} }

97
ges/ges-timeline.c
View file

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

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

@ -67,12 +67,12 @@ enum
}; };
static GESTrackElement static GESTrackElement
* ges_title_clip_create_track_element (GESClip * obj, GESTrackType type); * ges_title_clip_create_track_element (GESClip * clip, GESTrackType type);
static void static void
ges_title_clip_track_element_added (GESClip * obj, ges_title_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement); GESTrackElement * trackelement);
static void ges_title_clip_track_element_released (GESClip * obj, static void ges_title_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement); GESTrackElement * trackelement);
static void static void
@ -593,44 +593,44 @@ ges_title_clip_get_ypos (GESTitleClip * self)
} }
static void static void
ges_title_clip_track_element_released (GESClip * obj, ges_title_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement) 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 this is called, we should be sure the trackelement exists */
if (GES_IS_TITLE_SOURCE (trackelement)) { 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); priv->track_titles = g_slist_remove (priv->track_titles, trackelement);
g_object_unref (trackelement); g_object_unref (trackelement);
} }
} }
static void static void
ges_title_clip_track_element_added (GESClip * obj, ges_title_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement) GESTrackElement * trackelement)
{ {
GESTitleClipPrivate *priv = GES_TITLE_CLIP (obj)->priv; GESTitleClipPrivate *priv = GES_TITLE_CLIP (clip)->priv;
if (GES_IS_TITLE_SOURCE (trackelement)) { 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 = priv->track_titles =
g_slist_prepend (priv->track_titles, g_object_ref (trackelement)); g_slist_prepend (priv->track_titles, g_object_ref (trackelement));
} }
} }
static GESTrackElement * 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; GESTrackElement *res = NULL;
GST_DEBUG_OBJECT (obj, "a GESTitleSource"); GST_DEBUG_OBJECT (clip, "a GESTitleSource");
if (type == GES_TRACK_TYPE_VIDEO) { if (type == GES_TRACK_TYPE_VIDEO) {
res = (GESTrackElement *) ges_title_source_new (); 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_text ((GESTitleSource *) res, priv->text);
ges_title_source_set_font_desc ((GESTitleSource *) res, priv->font_desc); ges_title_source_set_font_desc ((GESTitleSource *) res, priv->font_desc);
ges_title_source_set_halignment ((GESTitleSource *) res, priv->halign); 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); object);
static void gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg 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 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 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 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 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_properties_signals (GESTrackElement * object);
static void connect_signal (gpointer key, gpointer value, gpointer user_data); static void connect_signal (gpointer key, gpointer value, gpointer user_data);
static void gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg 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_start (GESTimelineElement * element, GstClockTime start);
static gboolean _set_inpoint (GESTimelineElement * element, static gboolean _set_inpoint (GESTimelineElement * element,
@ -131,20 +131,20 @@ static void
ges_track_element_get_property (GObject * object, guint property_id, ges_track_element_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GESTrackElement *tobj = GES_TRACK_ELEMENT (object); GESTrackElement *track_element = GES_TRACK_ELEMENT (object);
switch (property_id) { switch (property_id) {
case PROP_ACTIVE: 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; break;
case PROP_LOCKED: 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; break;
case PROP_TRACK_TYPE: case PROP_TRACK_TYPE:
g_value_set_flags (value, tobj->priv->track_type); g_value_set_flags (value, track_element->priv->track_type);
break; break;
case PROP_TRACK: case PROP_TRACK:
g_value_set_object (value, tobj->priv->track); g_value_set_object (value, track_element->priv->track);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); 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, ges_track_element_set_property (GObject * object, guint property_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)
{ {
GESTrackElement *tobj = GES_TRACK_ELEMENT (object); GESTrackElement *track_element = GES_TRACK_ELEMENT (object);
switch (property_id) { switch (property_id) {
case PROP_ACTIVE: 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; break;
case PROP_LOCKED: 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; break;
case PROP_TRACK_TYPE: case PROP_TRACK_TYPE:
tobj->priv->track_type = g_value_get_flags (value); track_element->priv->track_type = g_value_get_flags (value);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); 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 */ /* Callbacks from the GNonLin object */
static void static void
gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED, gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj) GESTrackElement * track_element)
{ {
guint64 start; guint64 start;
g_object_get (gnlobject, "start", &start, NULL); g_object_get (gnlobject, "start", &start, NULL);
GST_DEBUG ("gnlobject start : %" GST_TIME_FORMAT " current : %" 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)) { if (start != _START (track_element)) {
_START (obj) = start; _START (track_element) = start;
g_object_notify (G_OBJECT (obj), "start"); g_object_notify (G_OBJECT (track_element), "start");
} }
} }
static void static void
gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg 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); GST_ELEMENT (element), arg);
} }
@ -484,77 +486,80 @@ connect_properties_signals (GESTrackElement * object)
/* Callbacks from the GNonLin object */ /* Callbacks from the GNonLin object */
static void static void
gnlobject_media_start_cb (GstElement * gnlobject, gnlobject_media_start_cb (GstElement * gnlobject,
GParamSpec * arg G_GNUC_UNUSED, GESTrackElement * obj) GParamSpec * arg G_GNUC_UNUSED, GESTrackElement * track_element)
{ {
guint64 inpoint; guint64 inpoint;
g_object_get (gnlobject, "media-start", &inpoint, NULL); g_object_get (gnlobject, "media-start", &inpoint, NULL);
GST_DEBUG ("gnlobject in-point : %" GST_TIME_FORMAT " current : %" 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)) { if (inpoint != _INPOINT (track_element)) {
_INPOINT (obj) = inpoint; _INPOINT (track_element) = inpoint;
g_object_notify (G_OBJECT (obj), "in-point"); g_object_notify (G_OBJECT (track_element), "in-point");
} }
} }
static void static void
gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED, gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj) GESTrackElement * track_element)
{ {
guint32 priority; guint32 priority;
g_object_get (gnlobject, "priority", &priority, NULL); 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)) { if (priority != _PRIORITY (track_element)) {
_PRIORITY (obj) = priority; _PRIORITY (track_element) = priority;
g_object_notify (G_OBJECT (obj), "priority"); g_object_notify (G_OBJECT (track_element), "priority");
} }
} }
static void static void
gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED, gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj) GESTrackElement * track_element)
{ {
guint64 duration; guint64 duration;
GESTrackElementClass *klass; GESTrackElementClass *klass;
klass = GES_TRACK_ELEMENT_GET_CLASS (obj); klass = GES_TRACK_ELEMENT_GET_CLASS (track_element);
g_object_get (gnlobject, "duration", &duration, NULL); g_object_get (gnlobject, "duration", &duration, NULL);
GST_DEBUG_OBJECT (gnlobject, "duration : %" GST_TIME_FORMAT " current : %" GST_DEBUG_OBJECT (gnlobject, "duration : %" GST_TIME_FORMAT " current : %"
GST_TIME_FORMAT, GST_TIME_ARGS (duration), GST_TIME_FORMAT, GST_TIME_ARGS (duration),
GST_TIME_ARGS (_DURATION (obj))); GST_TIME_ARGS (_DURATION (track_element)));
if (duration != _DURATION (obj)) { if (duration != _DURATION (track_element)) {
_DURATION (obj) = duration; _DURATION (track_element) = duration;
if (klass->duration_changed) if (klass->duration_changed)
klass->duration_changed (obj, duration); klass->duration_changed (track_element, duration);
g_object_notify (G_OBJECT (obj), "duration"); g_object_notify (G_OBJECT (track_element), "duration");
} }
} }
static void static void
gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED, gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
GESTrackElement * obj) GESTrackElement * track_element)
{ {
gboolean active; gboolean active;
GESTrackElementClass *klass; GESTrackElementClass *klass;
klass = GES_TRACK_ELEMENT_GET_CLASS (obj); klass = GES_TRACK_ELEMENT_GET_CLASS (track_element);
g_object_get (gnlobject, "active", &active, NULL); 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) { if (active != track_element->active) {
obj->active = active; track_element->active = active;
if (klass->active_changed) 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 static GESTrackElement *_create_track_element (GESClip
* self, GESTrackType type); * self, GESTrackType type);
static void static void
ges_transition_clip_track_element_added (GESClip * obj, ges_transition_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement); GESTrackElement * trackelement);
static void ges_transition_clip_track_element_released (GESClip * obj, static void ges_transition_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement); GESTrackElement * trackelement);
/* Internal methods */ /* Internal methods */
@ -268,14 +268,14 @@ ges_transition_clip_init (GESTransitionClip * self)
} }
static void static void
ges_transition_clip_track_element_released (GESClip * obj, ges_transition_clip_track_element_released (GESClip * clip,
GESTrackElement * trackelement) 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 this is called, we should be sure the trackelement exists */
if (GES_IS_VIDEO_TRANSITION (trackelement)) { 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 = priv->video_transitions =
g_slist_remove (priv->video_transitions, trackelement); g_slist_remove (priv->video_transitions, trackelement);
g_object_unref (trackelement); g_object_unref (trackelement);
@ -283,28 +283,28 @@ ges_transition_clip_track_element_released (GESClip * obj,
} }
static void static void
ges_transition_clip_track_element_added (GESClip * obj, ges_transition_clip_track_element_added (GESClip * clip,
GESTrackElement * trackelement) GESTrackElement * trackelement)
{ {
GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (obj)->priv; GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (clip)->priv;
if (GES_IS_VIDEO_TRANSITION (trackelement)) { 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 = priv->video_transitions =
g_slist_prepend (priv->video_transitions, g_object_ref (trackelement)); g_slist_prepend (priv->video_transitions, g_object_ref (trackelement));
} }
} }
static GESTrackElement * 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; GESTrackElement *res = NULL;
GESTrackType supportedformats; GESTrackType supportedformats;
GST_DEBUG ("Creating a GESTransition"); 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 (type == GES_TRACK_TYPE_VIDEO) {
if (supportedformats == GES_TRACK_TYPE_UNKNOWN || if (supportedformats == GES_TRACK_TYPE_UNKNOWN ||
supportedformats & GES_TRACK_TYPE_VIDEO) { 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 * static GList *ges_uri_clip_create_track_elements (GESClip *
obj, GESTrackType type); clip, GESTrackType type);
static GESTrackElement 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); void ges_uri_clip_set_uri (GESUriClip * self, gchar * uri);
gboolean gboolean
@ -281,14 +281,14 @@ void
ges_uri_clip_set_mute (GESUriClip * self, gboolean mute) ges_uri_clip_set_mute (GESUriClip * self, gboolean mute)
{ {
GList *tmp, *trackelements; GList *tmp, *trackelements;
GESClip *object = (GESClip *) self; GESClip *clip = (GESClip *) self;
GST_DEBUG ("self:%p, mute:%d", self, mute); GST_DEBUG ("self:%p, mute:%d", self, mute);
self->priv->mute = mute; self->priv->mute = mute;
/* Go over tracked objects, and update 'active' status on all audio objects */ /* 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) { for (tmp = trackelements; tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data; GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
@ -370,16 +370,16 @@ ges_uri_clip_get_uri (GESUriClip * self)
} }
static GList * 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; GList *res = NULL;
const GList *tmp, *stream_assets; 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 = stream_assets =
ges_uri_clip_asset_get_stream_assets (GES_URI_CLIP_ASSET 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) { for (tmp = stream_assets; tmp; tmp = tmp->next) {
GESTrackElementAsset *asset = GES_TRACK_ELEMENT_ASSET (tmp->data); GESTrackElementAsset *asset = GES_TRACK_ELEMENT_ASSET (tmp->data);
@ -391,9 +391,9 @@ ges_uri_clip_create_track_elements (GESClip * obj, GESTrackType type)
} }
static GESTrackElement * 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; GESTrackElement *res;
if (priv->is_image) { if (priv->is_image) {

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

@ -118,12 +118,12 @@ ges_track_filesource_dispose (GObject * object)
} }
static GstElement * static GstElement *
ges_track_filesource_create_gnl_object (GESTrackElement * object) ges_track_filesource_create_gnl_object (GESTrackElement * track_element)
{ {
GstElement *gnlobject; GstElement *gnlobject;
gnlobject = gst_element_factory_make ("gnlurisource", NULL); 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; return gnlobject;
} }

10
tests/benchmarks/timeline.c
View file

@ -30,7 +30,7 @@ main (gint argc, gchar * argv[])
GESAsset *asset; GESAsset *asset;
GESTimeline *timeline; GESTimeline *timeline;
GESTimelineLayer *layer; GESTimelineLayer *layer;
GESClip *object; GESClip *clip;
GstClockTime start, start_ripple, end, end_ripple, max_rippling_time = 0, GstClockTime start, start_ripple, end, end_ripple, max_rippling_time = 0,
min_rippling_time = GST_CLOCK_TIME_NONE; min_rippling_time = GST_CLOCK_TIME_NONE;
@ -43,20 +43,20 @@ main (gint argc, gchar * argv[])
ges_timeline_add_layer (timeline, layer); ges_timeline_add_layer (timeline, layer);
start = gst_util_get_timestamp (); 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)); 0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
for (i = 1; i < NUM_OBJECTS; i++) for (i = 1; i < NUM_OBJECTS; i++)
ges_timeline_layer_add_asset (layer, asset, i * 1000, 0, ges_timeline_layer_add_asset (layer, asset, i * 1000, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN); 1000, 1, GES_TRACK_TYPE_UNKNOWN);
end = gst_util_get_timestamp (); 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); GST_TIME_ARGS (end - start), i);
start_ripple = gst_util_get_timestamp (); start_ripple = gst_util_get_timestamp ();
for (i = 1; i < 501; i++) { for (i = 1; i < 501; i++) {
start = gst_util_get_timestamp (); 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); GES_EDGE_NONE, i * 1000);
end = gst_util_get_timestamp (); end = gst_util_get_timestamp ();
max_rippling_time = MAX (max_rippling_time, end - start); max_rippling_time = MAX (max_rippling_time, end - start);
@ -75,7 +75,7 @@ main (gint argc, gchar * argv[])
start_ripple = gst_util_get_timestamp (); start_ripple = gst_util_get_timestamp ();
for (i = 1; i < 501; i++) { for (i = 1; i < 501; i++) {
start = gst_util_get_timestamp (); 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); GES_EDGE_NONE, i * 1000);
end = gst_util_get_timestamp (); end = gst_util_get_timestamp ();
max_rippling_time = MAX (max_rippling_time, end - start); 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; GESTrack *track;
GESTrackElement *trackelement; GESTrackElement *trackelement;
GESClip *object; GESClip *clip;
ges_init (); ges_init ();
track = ges_track_new (GES_TRACK_TYPE_AUDIO, gst_caps_ref (GST_CAPS_ANY)); track = ges_track_new (GES_TRACK_TYPE_AUDIO, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL); fail_unless (track != NULL);
object = (GESClip *) clip = (GESClip *)
ges_test_clip_new (); ges_test_clip_new ();
fail_unless (object != NULL); fail_unless (clip != NULL);
/* Set some properties */ /* 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); "in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 51); assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type); trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (object, trackelement); ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track)); fail_unless (ges_track_element_set_track (trackelement, track));
@ -72,11 +72,11 @@ GST_START_TEST (test_test_source_properties)
51, 0, TRUE); 51, 0, TRUE);
/* Change more properties, see if they propagate */ /* 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); "in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420); assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (object), 510); assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (object), 120); assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420); assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510); assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120); assert_equals_uint64 (_INPOINT (trackelement), 120);
@ -86,15 +86,15 @@ GST_START_TEST (test_test_source_properties)
120, 510, 0, TRUE); 120, 510, 0, TRUE);
/* Test mute support */ /* 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, FALSE); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, TRUE); 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);
} }
GST_END_TEST; GST_END_TEST;
@ -104,7 +104,7 @@ GST_START_TEST (test_test_source_in_layer)
GESTimeline *timeline; GESTimeline *timeline;
GESTimelineLayer *layer; GESTimelineLayer *layer;
GESTrack *a, *v; GESTrack *a, *v;
GESTrackElement *trobj; GESTrackElement *track_element;
GESTestClip *source; GESTestClip *source;
GESVideoTestPattern ptrn; GESVideoTestPattern ptrn;
gdouble freq, volume; gdouble freq, volume;
@ -134,22 +134,22 @@ GST_START_TEST (test_test_source_in_layer)
g_object_get (source, "vpattern", &ptrn, NULL); g_object_get (source, "vpattern", &ptrn, NULL);
assert_equals_int (ptrn, GES_VIDEO_TEST_PATTERN_WHITE); assert_equals_int (ptrn, GES_VIDEO_TEST_PATTERN_WHITE);
trobj = track_element =
ges_clip_find_track_element (GES_CLIP (source), v, ges_clip_find_track_element (GES_CLIP (source), v,
GES_TYPE_VIDEO_TEST_SOURCE); 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 *) ptrn = (ges_video_test_source_get_pattern ((GESVideoTestSource *)
trobj)); track_element));
assert_equals_int (ptrn, GES_VIDEO_TEST_PATTERN_WHITE); assert_equals_int (ptrn, GES_VIDEO_TEST_PATTERN_WHITE);
g_object_unref (trobj); g_object_unref (track_element);
/* test audio properties as well */ /* 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); 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_frequency (source), 440);
assert_equals_float (ges_test_clip_get_volume (source), 0); 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); assert_equals_float (volume, 0);
freq = ges_audio_test_source_get_freq (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 (trobj)); volume =
ges_audio_test_source_get_volume (GES_AUDIO_TEST_SOURCE (track_element));
g_assert (freq == 440); g_assert (freq == 440);
g_assert (volume == 0); g_assert (volume == 0);
@ -170,12 +171,13 @@ GST_START_TEST (test_test_source_in_layer)
assert_equals_float (freq, 2000); assert_equals_float (freq, 2000);
assert_equals_float (volume, 0.5); assert_equals_float (volume, 0.5);
freq = ges_audio_test_source_get_freq (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 (trobj)); volume =
ges_audio_test_source_get_volume (GES_AUDIO_TEST_SOURCE (track_element));
g_assert (freq == 2000); g_assert (freq == 2000);
g_assert (volume == 0.5); g_assert (volume == 0.5);
g_object_unref (trobj); g_object_unref (track_element);
ges_timeline_layer_remove_clip (layer, (GESClip *) source); ges_timeline_layer_remove_clip (layer, (GESClip *) source);
@ -230,7 +232,7 @@ GST_START_TEST (test_gap_filling_basic)
GESTrack *track; GESTrack *track;
GESTrackElement *trackelement, *trackelement1, *trackelement2; GESTrackElement *trackelement, *trackelement1, *trackelement2;
/*GESTimelineLayer *layer; */ /*GESTimelineLayer *layer; */
GESClip *object, *object1, *object2; GESClip *clip, *clip1, *clip2;
GstElement *gnlsrc, *gnlsrc1, *gap = NULL; GstElement *gnlsrc, *gnlsrc1, *gap = NULL;
GstElement *composition; GstElement *composition;
GList *tmp; GList *tmp;
@ -243,16 +245,16 @@ GST_START_TEST (test_gap_filling_basic)
composition = find_composition (track); composition = find_composition (track);
fail_unless (composition != NULL); fail_unless (composition != NULL);
object = GES_CLIP (ges_test_clip_new ()); clip = GES_CLIP (ges_test_clip_new ());
fail_unless (object != NULL); fail_unless (clip != NULL);
/* Set some properties */ /* Set some properties */
g_object_set (object, "start", (guint64) 0, "duration", (guint64) 5, NULL); g_object_set (clip, "start", (guint64) 0, "duration", (guint64) 5, NULL);
assert_equals_uint64 (_START (object), 0); assert_equals_uint64 (_START (clip), 0);
assert_equals_uint64 (_DURATION (object), 5); assert_equals_uint64 (_DURATION (clip), 5);
trackelement = ges_clip_create_track_element (object, track->type); trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (object, trackelement); ges_clip_add_track_element (clip, trackelement);
fail_unless (ges_track_add_element (track, trackelement)); fail_unless (ges_track_add_element (track, trackelement));
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
@ -266,15 +268,15 @@ GST_START_TEST (test_gap_filling_basic)
/* Check no gap were wrongly added */ /* Check no gap were wrongly added */
assert_equals_int (g_list_length (GST_BIN_CHILDREN (composition)), 1); assert_equals_int (g_list_length (GST_BIN_CHILDREN (composition)), 1);
object1 = GES_CLIP (ges_test_clip_new ()); clip1 = GES_CLIP (ges_test_clip_new ());
fail_unless (object1 != NULL); fail_unless (clip1 != NULL);
g_object_set (object1, "start", (guint64) 15, "duration", (guint64) 5, NULL); g_object_set (clip1, "start", (guint64) 15, "duration", (guint64) 5, NULL);
assert_equals_uint64 (_START (object1), 15); assert_equals_uint64 (_START (clip1), 15);
assert_equals_uint64 (_DURATION (object1), 5); assert_equals_uint64 (_DURATION (clip1), 5);
trackelement1 = ges_clip_create_track_element (object1, track->type); trackelement1 = ges_clip_create_track_element (clip1, track->type);
ges_clip_add_track_element (object1, trackelement1); ges_clip_add_track_element (clip1, trackelement1);
fail_unless (ges_track_add_element (track, trackelement1)); fail_unless (ges_track_add_element (track, trackelement1));
fail_unless (trackelement1 != NULL); fail_unless (trackelement1 != NULL);
gnlsrc1 = ges_track_element_get_gnlobject (trackelement1); gnlsrc1 = ges_track_element_get_gnlobject (trackelement1);
@ -295,13 +297,13 @@ GST_START_TEST (test_gap_filling_basic)
} }
} }
fail_unless (gap != NULL); 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 ()); clip2 = GES_CLIP (ges_test_clip_new ());
fail_unless (object2 != NULL); fail_unless (clip2 != NULL);
g_object_set (object2, "start", (guint64) 35, "duration", (guint64) 5, NULL); g_object_set (clip2, "start", (guint64) 35, "duration", (guint64) 5, NULL);
trackelement2 = ges_clip_create_track_element (object2, track->type); trackelement2 = ges_clip_create_track_element (clip2, track->type);
ges_clip_add_track_element (object2, trackelement2); ges_clip_add_track_element (clip2, trackelement2);
fail_unless (ges_track_add_element (track, trackelement2)); fail_unless (ges_track_add_element (track, trackelement2));
fail_unless (trackelement2 != NULL); fail_unless (trackelement2 != NULL);
assert_equals_uint64 (_START (trackelement2), 35); 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; GST_END_TEST;
static gboolean static gboolean
my_fill_track_func (GESClip * object, my_fill_track_func (GESClip * clip,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data) GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{ {
GstElement *src; GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelement:%p, gnlobj:%p", 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 */ /* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL); src = gst_element_factory_make ("fakesrc", NULL);
@ -564,13 +564,13 @@ typedef struct
} SelectTracksData; } SelectTracksData;
static GPtrArray * static GPtrArray *
select_tracks_cb (GESTimeline * timeline, GESClip * tobj, select_tracks_cb (GESTimeline * timeline, GESClip * clip,
GESTrackElement * trobj, SelectTracksData * st_data) GESTrackElement * track_element, SelectTracksData * st_data)
{ {
GESTrack *track; GESTrack *track;
GPtrArray *ret = g_ptr_array_new (); 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); gst_object_ref (track);

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

@ -22,13 +22,13 @@
#include <gst/check/gstcheck.h> #include <gst/check/gstcheck.h>
static gboolean static gboolean
my_fill_track_func (GESClip * object, my_fill_track_func (GESClip * clip,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data) GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{ {
GstElement *src; GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p", 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 */ /* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL); src = gst_element_factory_make ("fakesrc", NULL);
@ -43,25 +43,25 @@ GST_START_TEST (test_object_properties)
{ {
GESTrack *track; GESTrack *track;
GESTrackElement *trackelement; GESTrackElement *trackelement;
GESClip *object; GESClip *clip;
ges_init (); ges_init ();
track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY)); track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL); fail_unless (track != NULL);
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL); clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL); fail_unless (clip != NULL);
/* Set some properties */ /* 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); "in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 51); assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type); trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (object, trackelement); ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track)); fail_unless (ges_track_element_set_track (trackelement, track));
@ -75,11 +75,11 @@ GST_START_TEST (test_object_properties)
51, 0, TRUE); 51, 0, TRUE);
/* Change more properties, see if they propagate */ /* 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); "in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420); assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (object), 510); assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (object), 120); assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420); assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510); assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120); 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 /* 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); 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); assert_equals_uint64 (_START (trackelement), 400);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 510, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 510,
120, 510, 0, TRUE); 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); g_object_unref (track);
} }
@ -109,25 +109,25 @@ GST_START_TEST (test_object_properties_unlocked)
{ {
GESTrack *track; GESTrack *track;
GESTrackElement *trackelement; GESTrackElement *trackelement;
GESClip *object; GESClip *clip;
ges_init (); ges_init ();
track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY)); track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL); fail_unless (track != NULL);
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL); clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL); fail_unless (clip != NULL);
/* Set some properties */ /* 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); "in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 51); assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type); trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (object, trackelement); ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track)); 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); ges_track_element_set_locked (trackelement, FALSE);
/* Change more properties, they will be set on the GESClip */ /* 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); "in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420); assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (object), 510); assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (object), 120); assert_equals_uint64 (_INPOINT (clip), 120);
/* ... but not on the GESTrackElement since it was unlocked... */ /* ... but not on the GESTrackElement since it was unlocked... */
assert_equals_uint64 (_START (trackelement), 42); assert_equals_uint64 (_START (trackelement), 42);
assert_equals_uint64 (_DURATION (trackelement), 51); assert_equals_uint64 (_DURATION (trackelement), 51);
assert_equals_uint64 (_INPOINT (trackelement), 12); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE); 51, 0, TRUE);
/* When unlocked, moving the GESTrackElement won't move the GESClip /* When unlocked, moving the GESTrackElement won't move the GESClip
* either */ * either */
/* This time, we move the trackelement to see if the changes move /* 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); 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); assert_equals_uint64 (_START (trackelement), 400);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 51, 12, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 51, 12,
51, 0, TRUE); 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); g_object_unref (track);
} }
@ -180,7 +180,7 @@ GST_START_TEST (test_split_object)
{ {
GESTrack *track; GESTrack *track;
GESTrackElement *trackelement, *splittrackelement; GESTrackElement *trackelement, *splittrackelement;
GESClip *object, *splitobj; GESClip *clip, *splitclip;
GList *splittrackelements; GList *splittrackelements;
ges_init (); 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)); track = ges_track_new (GES_TRACK_TYPE_CUSTOM, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL); fail_unless (track != NULL);
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL); clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL); fail_unless (clip != NULL);
/* Set some properties */ /* 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); "in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 50); assert_equals_uint64 (_DURATION (clip), 50);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type); trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (object, trackelement); ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track)); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 50, 12,
50, 0, TRUE); 50, 0, TRUE);
splitobj = ges_clip_split (object, 67); splitclip = ges_clip_split (clip, 67);
fail_unless (GES_IS_CLIP (splitobj)); fail_unless (GES_IS_CLIP (splitclip));
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 25); assert_equals_uint64 (_DURATION (clip), 25);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
assert_equals_uint64 (_START (splitobj), 67); assert_equals_uint64 (_START (splitclip), 67);
assert_equals_uint64 (_DURATION (splitobj), 25); assert_equals_uint64 (_DURATION (splitclip), 25);
assert_equals_uint64 (_INPOINT (splitobj), 37); 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); fail_unless_equals_int (g_list_length (splittrackelements), 1);
splittrackelement = GES_TRACK_ELEMENT (splittrackelements->data); splittrackelement = GES_TRACK_ELEMENT (splittrackelements->data);
@ -233,16 +233,16 @@ GST_START_TEST (test_split_object)
assert_equals_uint64 (_INPOINT (splittrackelement), 37); assert_equals_uint64 (_INPOINT (splittrackelement), 37);
fail_unless (splittrackelement != trackelement); fail_unless (splittrackelement != trackelement);
fail_unless (splitobj != object); fail_unless (splitclip != clip);
/* We own the only ref */ /* 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 */ /* 1 ref for the Clip, 1 ref for the Track and 1 in splittrackelements */
ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 3); ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 3);
g_object_unref (track); g_object_unref (track);
g_object_unref (splitobj); g_object_unref (splitclip);
g_object_unref (object); g_object_unref (clip);
ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 1); ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 1);
g_list_free_full (splittrackelements, g_object_unref); 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 <ges/ges.h>
#include <gst/check/gstcheck.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 void
deep_prop_changed_cb (GESTrackElement * obj, GstElement * element, deep_prop_changed_cb (GESTrackElement * track_element, GstElement * element,
GParamSpec * spec); GParamSpec * spec);
GST_START_TEST (test_effect_basic) GST_START_TEST (test_effect_basic)
@ -383,19 +383,19 @@ GST_START_TEST (test_base_effect_set_properties)
GST_END_TEST; GST_END_TEST;
void void
effect_added_cb (GESClip * obj, GESBaseEffect * trop, gpointer data) effect_added_cb (GESClip * clip, GESBaseEffect * trop, gpointer data)
{ {
GST_DEBUG ("Effect added"); GST_DEBUG ("Effect added");
fail_unless (GES_IS_CLIP (obj)); fail_unless (GES_IS_CLIP (clip));
fail_unless (GES_IS_BASE_EFFECT (trop)); fail_unless (GES_IS_BASE_EFFECT (trop));
} }
void void
deep_prop_changed_cb (GESTrackElement * obj, GstElement * element, deep_prop_changed_cb (GESTrackElement * track_element, GstElement * element,
GParamSpec * spec) GParamSpec * spec)
{ {
GST_DEBUG ("%s property changed", g_param_spec_get_name (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)); fail_unless (GST_IS_ELEMENT (element));
} }

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

@ -24,13 +24,13 @@
#define LAYER_HEIGHT 1000 #define LAYER_HEIGHT 1000
static gboolean static gboolean
my_fill_track_func (GESClip * object, my_fill_track_func (GESClip * clip,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data) GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{ {
GstElement *src; GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p", 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 */ /* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL); src = gst_element_factory_make ("fakesrc", NULL);
@ -48,7 +48,7 @@ GST_START_TEST (test_layer_properties)
GESTimelineLayer *layer; GESTimelineLayer *layer;
GESTrack *track; GESTrack *track;
GESTrackElement *trackelement; GESTrackElement *trackelement;
GESClip *object; GESClip *clip;
ges_init (); ges_init ();
@ -69,55 +69,55 @@ GST_START_TEST (test_layer_properties)
fail_unless (track != NULL); fail_unless (track != NULL);
fail_unless (ges_timeline_add_track (timeline, track)); fail_unless (ges_timeline_add_track (timeline, track));
object = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL); clip = (GESClip *) ges_custom_source_clip_new (my_fill_track_func, NULL);
fail_unless (object != NULL); fail_unless (clip != NULL);
/* Set some properties */ /* 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); "in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 51); assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
assert_equals_uint64 (_PRIORITY (object), 0); assert_equals_uint64 (_PRIORITY (clip), 0);
/* Add the object to the timeline */ /* Add the clip to the timeline */
fail_unless (g_object_is_floating (object)); fail_unless (g_object_is_floating (clip));
fail_unless (ges_timeline_layer_add_clip (layer, GES_CLIP (object))); fail_unless (ges_timeline_layer_add_clip (layer, GES_CLIP (clip)));
fail_if (g_object_is_floating (object)); fail_if (g_object_is_floating (clip));
trackelement = ges_clip_find_track_element (object, track, G_TYPE_NONE); trackelement = ges_clip_find_track_element (clip, track, G_TYPE_NONE);
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
/* This is not a SimpleLayer, therefore the properties shouldn't have changed */ /* This is not a SimpleLayer, therefore the properties shouldn't have changed */
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 51); assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
assert_equals_uint64 (_PRIORITY (object), 0); assert_equals_uint64 (_PRIORITY (clip), 0);
gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE); 51, 0, TRUE);
/* Change the priority of the layer */ /* Change the priority of the layer */
g_object_set (layer, "priority", 1, NULL); g_object_set (layer, "priority", 1, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 1); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, LAYER_HEIGHT, TRUE); 51, LAYER_HEIGHT, TRUE);
/* Change it to an insanely high value */ /* Change it to an insanely high value */
g_object_set (layer, "priority", 31, NULL); g_object_set (layer, "priority", 31, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 31); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, LAYER_HEIGHT * 31, TRUE); 51, LAYER_HEIGHT * 31, TRUE);
/* and back to 0 */ /* and back to 0 */
g_object_set (layer, "priority", 0, NULL); g_object_set (layer, "priority", 0, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 0); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE); 51, 0, TRUE);
g_object_unref (trackelement); 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_track (timeline, track));
fail_unless (ges_timeline_remove_layer (timeline, layer)); fail_unless (ges_timeline_remove_layer (timeline, layer));
g_object_unref (timeline); g_object_unref (timeline);
@ -131,7 +131,7 @@ GST_START_TEST (test_layer_priorities)
GESTimeline *timeline; GESTimeline *timeline;
GESTimelineLayer *layer1, *layer2, *layer3; GESTimelineLayer *layer1, *layer2, *layer3;
GESTrackElement *trackelement1, *trackelement2, *trackelement3; GESTrackElement *trackelement1, *trackelement2, *trackelement3;
GESClip *object1, *object2, *object3; GESClip *clip1, *clip2, *clip3;
GstElement *gnlobj1, *gnlobj2, *gnlobj3; GstElement *gnlobj1, *gnlobj2, *gnlobj3;
guint prio1, prio2, prio3; guint prio1, prio2, prio3;
GList *objs, *tmp; GList *objs, *tmp;
@ -158,57 +158,57 @@ GST_START_TEST (test_layer_priorities)
fail_unless (track != NULL); fail_unless (track != NULL);
fail_unless (ges_timeline_add_track (timeline, track)); fail_unless (ges_timeline_add_track (timeline, track));
object1 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL)); clip1 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (object1, ges_clip_set_supported_formats (clip1,
GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO); GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO);
object2 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL)); clip2 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (object2, ges_clip_set_supported_formats (clip2,
GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO); GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO);
object3 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL)); clip3 = GES_CLIP (ges_custom_source_clip_new (my_fill_track_func, NULL));
ges_clip_set_supported_formats (object3, ges_clip_set_supported_formats (clip3,
GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO); GES_TRACK_TYPE_AUDIO | GES_TRACK_TYPE_VIDEO);
fail_unless (object1 != NULL); fail_unless (clip1 != NULL);
fail_unless (object2 != NULL); fail_unless (clip2 != NULL);
fail_unless (object3 != NULL); fail_unless (clip3 != NULL);
/* Set priorities on the objects */ /* Set priorities on the objects */
g_object_set (object1, "priority", 0, NULL); g_object_set (clip1, "priority", 0, NULL);
assert_equals_int (_PRIORITY (object1), 0); assert_equals_int (_PRIORITY (clip1), 0);
g_object_set (object2, "priority", 1, NULL); g_object_set (clip2, "priority", 1, NULL);
assert_equals_int (_PRIORITY (object2), 1); assert_equals_int (_PRIORITY (clip2), 1);
g_object_set (object3, "priority", LAYER_HEIGHT + 1, NULL); g_object_set (clip3, "priority", LAYER_HEIGHT + 1, NULL);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT + 1); assert_equals_int (_PRIORITY (clip3), LAYER_HEIGHT + 1);
/* Add objects to the timeline */ /* Add objects to the timeline */
fail_unless (ges_timeline_layer_add_clip (layer1, object1)); fail_unless (ges_timeline_layer_add_clip (layer1, clip1));
trackelement1 = ges_clip_find_track_element (object1, track, G_TYPE_NONE); trackelement1 = ges_clip_find_track_element (clip1, track, G_TYPE_NONE);
fail_unless (trackelement1 != NULL); fail_unless (trackelement1 != NULL);
fail_unless (ges_timeline_layer_add_clip (layer2, object2)); fail_unless (ges_timeline_layer_add_clip (layer2, clip2));
trackelement2 = ges_clip_find_track_element (object2, track, G_TYPE_NONE); trackelement2 = ges_clip_find_track_element (clip2, track, G_TYPE_NONE);
fail_unless (trackelement2 != NULL); fail_unless (trackelement2 != NULL);
fail_unless (ges_timeline_layer_add_clip (layer3, object3)); fail_unless (ges_timeline_layer_add_clip (layer3, clip3));
trackelement3 = ges_clip_find_track_element (object3, track, G_TYPE_NONE); trackelement3 = ges_clip_find_track_element (clip3, track, G_TYPE_NONE);
fail_unless (trackelement3 != NULL); fail_unless (trackelement3 != NULL);
assert_equals_int (_PRIORITY (object1), 0); assert_equals_int (_PRIORITY (clip1), 0);
gnlobj1 = ges_track_element_get_gnlobject (trackelement1); gnlobj1 = ges_track_element_get_gnlobject (trackelement1);
fail_unless (gnlobj1 != NULL); fail_unless (gnlobj1 != NULL);
g_object_get (gnlobj1, "priority", &prio1, NULL); g_object_get (gnlobj1, "priority", &prio1, NULL);
assert_equals_int (prio1, 0); assert_equals_int (prio1, 0);
assert_equals_int (_PRIORITY (object2), 1); assert_equals_int (_PRIORITY (clip2), 1);
gnlobj2 = ges_track_element_get_gnlobject (trackelement2); gnlobj2 = ges_track_element_get_gnlobject (trackelement2);
fail_unless (gnlobj2 != NULL); fail_unless (gnlobj2 != NULL);
g_object_get (gnlobj2, "priority", &prio2, 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 (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); gnlobj3 = ges_track_element_get_gnlobject (trackelement3);
fail_unless (gnlobj3 != NULL); 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*/ * it priority must have the maximum priority of this layer*/
g_object_get (gnlobj3, "priority", &prio3, NULL); g_object_get (gnlobj3, "priority", &prio3, NULL);
assert_equals_int (prio3, LAYER_HEIGHT * 3 - 1); 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 (layer1), 2);
assert_equals_int (ges_timeline_layer_get_priority (layer2), 0); assert_equals_int (ges_timeline_layer_get_priority (layer2), 0);
assert_equals_int (ges_timeline_layer_get_priority (layer3), 1); assert_equals_int (ges_timeline_layer_get_priority (layer3), 1);
assert_equals_int (_PRIORITY (object1), 0); assert_equals_int (_PRIORITY (clip1), 0);
assert_equals_int (_PRIORITY (object2), 1); assert_equals_int (_PRIORITY (clip2), 1);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT - 1); assert_equals_int (_PRIORITY (clip3), LAYER_HEIGHT - 1);
g_object_get (gnlobj1, "priority", &prio1, NULL); g_object_get (gnlobj1, "priority", &prio1, NULL);
g_object_get (gnlobj2, "priority", &prio2, NULL); g_object_get (gnlobj2, "priority", &prio2, NULL);
g_object_get (gnlobj3, "priority", &prio3, 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); assert_equals_int (prio3, LAYER_HEIGHT * 2 - 1);
/* And move objects around */ /* And move objects around */
fail_unless (ges_clip_move_to_layer (object2, layer1)); fail_unless (ges_clip_move_to_layer (clip2, layer1));
fail_unless (ges_clip_move_to_layer (object3, layer1)); fail_unless (ges_clip_move_to_layer (clip3, layer1));
objs = ges_timeline_layer_get_clips (layer1); objs = ges_timeline_layer_get_clips (layer1);
assert_equals_int (g_list_length (objs), 3); assert_equals_int (g_list_length (objs), 3);
@ -247,9 +247,9 @@ GST_START_TEST (test_layer_priorities)
g_list_free (objs); g_list_free (objs);
/* Check their priorities (layer1 priority is now 2) */ /* Check their priorities (layer1 priority is now 2) */
assert_equals_int (_PRIORITY (object1), 0); assert_equals_int (_PRIORITY (clip1), 0);
assert_equals_int (_PRIORITY (object2), 1); assert_equals_int (_PRIORITY (clip2), 1);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT - 1); assert_equals_int (_PRIORITY (clip3), LAYER_HEIGHT - 1);
g_object_get (gnlobj1, "priority", &prio1, NULL); g_object_get (gnlobj1, "priority", &prio1, NULL);
g_object_get (gnlobj2, "priority", &prio2, NULL); g_object_get (gnlobj2, "priority", &prio2, NULL);
g_object_get (gnlobj3, "priority", &prio3, NULL); g_object_get (gnlobj3, "priority", &prio3, NULL);
@ -263,7 +263,7 @@ GST_START_TEST (test_layer_priorities)
LAYER_HEIGHT * 2); LAYER_HEIGHT * 2);
g_object_get (gnlobj3, "priority", &prio3, NULL); g_object_get (gnlobj3, "priority", &prio3, NULL);
assert_equals_int (prio3, 2 * LAYER_HEIGHT); 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 (trackelement1);
g_object_unref (trackelement2); 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)); fail_unless (ges_timeline_layer_get_auto_transition (layer));
GST_DEBUG ("Adding assets to first 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, src = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 0, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN)); 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src)); 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, src1 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN)); 0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src1)); 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); g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Adding asset to first layer"); 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 = src2 =
GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 1250, 0, GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 1250, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN)); 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); g_list_free_full (objects, gst_object_unref);
GST_DEBUG 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); ges_timeline_element_set_start (src2, 1100);
/* 600____src___1100 /* 600____src___1100
* 500___________src1________1250 * 500___________src1________1250
@ -614,7 +614,7 @@ GST_START_TEST (test_single_layer_automatic_transition)
fail_unless (current->data == src2); fail_unless (current->data == src2);
g_list_free_full (objects, gst_object_unref); 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_clip_edit (GES_CLIP (src2), NULL, -1,
GES_EDIT_MODE_NORMAL, GES_EDGE_START, 1000); GES_EDIT_MODE_NORMAL, GES_EDGE_START, 1000);
/* 600____src___1100 /* 600____src___1100
@ -709,12 +709,12 @@ GST_START_TEST (test_multi_layer_automatic_transition)
fail_if (ges_timeline_layer_get_auto_transition (layer1)); fail_if (ges_timeline_layer_get_auto_transition (layer1));
GST_DEBUG ("Adding assets to first 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, src = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 0, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN)); 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src)); 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, src1 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN)); 0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src1)); 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); g_list_free_full (objects, gst_object_unref);
ASSERT_OBJECT_REFCOUNT (transition, "Only the layer owns a ref", 1); 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, src2 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer1, asset, 0,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN)); 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, src3 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer1, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN)); 0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
assert_is_type (src3, GES_TYPE_TEST_CLIP); 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); layer = ges_timeline_append_layer (timeline);
assert_is_type (layer, GES_TYPE_TIMELINE_LAYER); 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, src = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 0, 0,
1000, 1, GES_TRACK_TYPE_UNKNOWN)); 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src)); 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, src1 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 500,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN)); 0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src1)); 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, src2 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 1000,
0, 1000, 1, GES_TRACK_TYPE_UNKNOWN)); 0, 1000, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src2)); 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, src3 = GES_TIMELINE_ELEMENT (ges_timeline_layer_add_asset (layer, asset, 2000,
0, 500, 1, GES_TRACK_TYPE_UNKNOWN)); 0, 500, 1, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_CLIP (src3)); 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; GESTrack *track;
GESTrackElement *trackelement; GESTrackElement *trackelement;
GESClip *object; GESClip *clip;
ges_init (); ges_init ();
track = ges_track_new (GES_TRACK_TYPE_VIDEO, gst_caps_ref (GST_CAPS_ANY)); track = ges_track_new (GES_TRACK_TYPE_VIDEO, gst_caps_ref (GST_CAPS_ANY));
fail_unless (track != NULL); fail_unless (track != NULL);
object = (GESClip *) clip = (GESClip *) ges_text_overlay_clip_new ();
ges_text_overlay_clip_new (); fail_unless (clip != NULL);
fail_unless (object != NULL);
/* Set some properties */ /* 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); "in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 51); assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type); trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (object, trackelement); ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track)); fail_unless (ges_track_element_set_track (trackelement, track));
@ -72,11 +71,11 @@ GST_START_TEST (test_overlay_properties)
51, 0, TRUE); 51, 0, TRUE);
/* Change more properties, see if they propagate */ /* 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); "in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420); assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (object), 510); assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (object), 120); assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420); assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510); assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, TRUE); 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);
} }
GST_END_TEST; GST_END_TEST;
@ -96,7 +95,7 @@ GST_START_TEST (test_overlay_in_layer)
GESTimeline *timeline; GESTimeline *timeline;
GESTimelineLayer *layer; GESTimelineLayer *layer;
GESTrack *a, *v; GESTrack *a, *v;
GESTrackElement *trobj; GESTrackElement *track_element;
GESTextOverlayClip *source; GESTextOverlayClip *source;
gchar *text; gchar *text;
gint halign, valign; gint halign, valign;
@ -128,7 +127,8 @@ GST_START_TEST (test_overlay_in_layer)
assert_equals_string ("some text", text); assert_equals_string ("some text", text);
g_free (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 */ /* test the font-desc property */
g_object_set (source, "font-desc", (gchar *) "sans 72", NULL); g_object_set (source, "font-desc", (gchar *) "sans 72", NULL);
@ -137,7 +137,7 @@ GST_START_TEST (test_overlay_in_layer)
g_free (text); g_free (text);
assert_equals_string ("sans 72", 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 */ /* test halign and valign */
g_object_set (source, "halignment", (gint) 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 (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP); assert_equals_int (valign, GES_TEXT_VALIGN_TOP);
halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (trobj)); halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (track_element));
valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (trobj)); valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (track_element));
assert_equals_int (halign, GES_TEXT_HALIGN_LEFT); assert_equals_int (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP); 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); g_object_get (source, "color", &color, NULL);
assert_equals_int (color, 2147483647); 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); assert_equals_int (color, 2147483647);
/* test xpos */ /* test xpos */
@ -164,7 +164,7 @@ GST_START_TEST (test_overlay_in_layer)
g_object_get (source, "xpos", &xpos, NULL); g_object_get (source, "xpos", &xpos, NULL);
assert_equals_float (xpos, 0.5); 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); assert_equals_float (xpos, 0.5);
/* test ypos */ /* test ypos */
@ -172,7 +172,7 @@ GST_START_TEST (test_overlay_in_layer)
g_object_get (source, "ypos", &ypos, NULL); g_object_get (source, "ypos", &ypos, NULL);
assert_equals_float (ypos, 0.33); 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); assert_equals_float (ypos, 0.33);
GST_DEBUG ("removing the source"); GST_DEBUG ("removing the source");
@ -181,7 +181,7 @@ GST_START_TEST (test_overlay_in_layer)
GST_DEBUG ("removing the layer"); GST_DEBUG ("removing the layer");
g_object_unref (trobj); g_object_unref (track_element);
g_object_unref (timeline); g_object_unref (timeline);
} }

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

@ -22,13 +22,13 @@
#include <gst/check/gstcheck.h> #include <gst/check/gstcheck.h>
static gboolean static gboolean
my_fill_track_func (GESClip * object, my_fill_track_func (GESClip * clip,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data) GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{ {
GstElement *src; GstElement *src;
GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p", 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 */ /* Let's just put a fakesource in for the time being */
src = gst_element_factory_make ("fakesrc", NULL); src = gst_element_factory_make ("fakesrc", NULL);
@ -41,15 +41,15 @@ my_fill_track_func (GESClip * object,
} }
static gboolean static gboolean
arbitrary_fill_track_func (GESClip * object, arbitrary_fill_track_func (GESClip * clip,
GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data) GESTrackElement * track_element, GstElement * gnlobj, gpointer user_data)
{ {
GstElement *src; GstElement *src;
g_assert (user_data); g_assert (user_data);
GST_DEBUG ("element:%s, timelineobj:%p, trackelements:%p, gnlobj:%p,", 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 */ /* interpret user_data as name of element to create */
src = gst_element_factory_make (user_data, NULL); src = gst_element_factory_make (user_data, NULL);
@ -126,7 +126,7 @@ typedef struct
static void static void
object_moved_cb (GESSimpleTimelineLayer * layer, object_moved_cb (GESSimpleTimelineLayer * layer,
GESClip * object, gint old, gint new, gpointer user) GESClip * clip, gint old, gint new, gpointer user)
{ {
siginfo *info; siginfo *info;
info = (siginfo *) user; 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; GESTimeline *timeline;
GESTimelineLayer *layer; GESTimelineLayer *layer;
GESTrack *a, *v; GESTrack *a, *v;
GESTrackElement *trobj; GESTrackElement *track_element;
GESTestClip *source; GESTestClip *source;
gchar *text; gchar *text;
gint halign, valign; gint halign, valign;
@ -49,11 +49,11 @@ GST_START_TEST (test_text_properties_in_layer)
ges_simple_timeline_layer_add_object ((GESSimpleTimelineLayer *) layer, ges_simple_timeline_layer_add_object ((GESSimpleTimelineLayer *) layer,
(GESClip *) source, 0); (GESClip *) source, 0);
trobj = track_element =
ges_clip_find_track_element (GES_CLIP (source), v, GES_TYPE_TEXT_OVERLAY); ges_clip_find_track_element (GES_CLIP (source), v, GES_TYPE_TEXT_OVERLAY);
fail_unless (trobj != NULL); fail_unless (track_element != NULL);
assert_equals_int (trobj->active, FALSE); assert_equals_int (track_element->active, FALSE);
/* specifically test the text property */ /* specifically test the text property */
g_object_set (source, "text", (gchar *) "some text", NULL); 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); assert_equals_string ("some text", text);
g_free (text); g_free (text);
assert_equals_int (trobj->active, TRUE); assert_equals_int (track_element->active, TRUE);
/* test the font-desc property */ /* test the font-desc property */
g_object_set (source, "font-desc", (gchar *) "sans 72", NULL); 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); g_free (text);
assert_equals_string ("sans 72", 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); 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 */ /* test halign and valign */
g_object_set (source, "halignment", (gint) 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 (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP); assert_equals_int (valign, GES_TEXT_VALIGN_TOP);
halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (trobj)); halign = ges_text_overlay_get_halignment (GES_TEXT_OVERLAY (track_element));
valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (trobj)); valign = ges_text_overlay_get_valignment (GES_TEXT_OVERLAY (track_element));
assert_equals_int (halign, GES_TEXT_HALIGN_LEFT); assert_equals_int (halign, GES_TEXT_HALIGN_LEFT);
assert_equals_int (valign, GES_TEXT_VALIGN_TOP); 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"); GST_DEBUG ("removing the layer");
g_object_unref (trobj); g_object_unref (track_element);
g_object_unref (timeline); 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; GESTrack *track;
GESTrackElement *trackelement; GESTrackElement *trackelement;
GESClip *object; GESClip *clip;
ges_init (); ges_init ();
track = ges_track_video_raw_new (); track = ges_track_video_raw_new ();
fail_unless (track != NULL); fail_unless (track != NULL);
object = (GESClip *) clip = (GESClip *)
ges_title_clip_new (); ges_title_clip_new ();
fail_unless (object != NULL); fail_unless (clip != NULL);
/* Set some properties */ /* 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); "in-point", (guint64) 12, NULL);
assert_equals_uint64 (_START (object), 42); assert_equals_uint64 (_START (clip), 42);
assert_equals_uint64 (_DURATION (object), 51); assert_equals_uint64 (_DURATION (clip), 51);
assert_equals_uint64 (_INPOINT (object), 12); assert_equals_uint64 (_INPOINT (clip), 12);
trackelement = ges_clip_create_track_element (object, track->type); trackelement = ges_clip_create_track_element (clip, track->type);
ges_clip_add_track_element (object, trackelement); ges_clip_add_track_element (clip, trackelement);
fail_unless (trackelement != NULL); fail_unless (trackelement != NULL);
fail_unless (ges_track_element_set_track (trackelement, track)); fail_unless (ges_track_element_set_track (trackelement, track));
@ -72,11 +72,11 @@ GST_START_TEST (test_title_source_properties)
51, 0, TRUE); 51, 0, TRUE);
/* Change more properties, see if they propagate */ /* 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); "in-point", (guint64) 120, NULL);
assert_equals_uint64 (_START (object), 420); assert_equals_uint64 (_START (clip), 420);
assert_equals_uint64 (_DURATION (object), 510); assert_equals_uint64 (_DURATION (clip), 510);
assert_equals_uint64 (_INPOINT (object), 120); assert_equals_uint64 (_INPOINT (clip), 120);
assert_equals_uint64 (_START (trackelement), 420); assert_equals_uint64 (_START (trackelement), 420);
assert_equals_uint64 (_DURATION (trackelement), 510); assert_equals_uint64 (_DURATION (trackelement), 510);
assert_equals_uint64 (_INPOINT (trackelement), 120); 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, gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
120, 510, 0, TRUE); 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);
} }
GST_END_TEST; GST_END_TEST;
@ -96,7 +96,7 @@ GST_START_TEST (test_title_source_in_layer)
GESTimeline *timeline; GESTimeline *timeline;
GESTimelineLayer *layer; GESTimelineLayer *layer;
GESTrack *a, *v; GESTrack *a, *v;
GESTrackElement *trobj; GESTrackElement *track_element;
GESTitleClip *source; GESTitleClip *source;
gchar *text; gchar *text;
gint halign, valign; gint halign, valign;
@ -128,12 +128,12 @@ GST_START_TEST (test_title_source_in_layer)
assert_equals_string ("some text", text); assert_equals_string ("some text", text);
g_free (text); g_free (text);
trobj = track_element =
ges_clip_find_track_element (GES_CLIP (source), v, GES_TYPE_TITLE_SOURCE); ges_clip_find_track_element (GES_CLIP (source), v, GES_TYPE_TITLE_SOURCE);
/* Check the text is still the same */ /* Check the text is still the same */
assert_equals_string (ges_title_source_get_text (GES_TITLE_SOURCE assert_equals_string (ges_title_source_get_text (GES_TITLE_SOURCE
(trobj)), "some text"); (track_element)), "some text");
/* test the font-desc property */ /* test the font-desc property */
g_object_set (source, "font-desc", (gchar *) "sans 72", NULL); 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); g_free (text);
assert_equals_string ("sans 72", 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 */ /* test halign and valign */
g_object_set (source, "halignment", (gint) 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 (valign, GES_TEXT_VALIGN_TOP);
assert_equals_int (ges_title_source_get_halignment 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 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 */ /* test color */
g_object_set (source, "color", (gint) 2147483647, NULL); g_object_set (source, "color", (gint) 2147483647, NULL);
g_object_get (source, "color", &color, NULL); g_object_get (source, "color", &color, NULL);
assert_equals_int (color, 2147483647); 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); assert_equals_int (color, 2147483647);
/* test xpos */ /* test xpos */
@ -169,7 +169,7 @@ GST_START_TEST (test_title_source_in_layer)
g_object_get (source, "xpos", &xpos, NULL); g_object_get (source, "xpos", &xpos, NULL);
assert_equals_float (xpos, 0.25); 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); assert_equals_float (xpos, 0.25);
/* test ypos */ /* test ypos */
@ -177,7 +177,7 @@ GST_START_TEST (test_title_source_in_layer)
g_object_get (source, "ypos", &ypos, NULL); g_object_get (source, "ypos", &ypos, NULL);
assert_equals_float (ypos, 0.66); 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); assert_equals_float (ypos, 0.66);
GST_DEBUG ("removing the source"); GST_DEBUG ("removing the source");
@ -186,7 +186,7 @@ GST_START_TEST (test_title_source_in_layer)
GST_DEBUG ("removing the layer"); GST_DEBUG ("removing the layer");
g_object_unref (trobj); g_object_unref (track_element);
g_object_unref (timeline); g_object_unref (timeline);
} }

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

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

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

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

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

@ -213,12 +213,12 @@ update_play_sensitivity (App * app)
/* Backend callbacks ********************************************************/ /* Backend callbacks ********************************************************/
static void 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) unused G_GNUC_UNUSED, App * app)
{ {
gdouble volume; 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); gtk_range_set_value (GTK_RANGE (app->volume), volume);
} }
@ -231,18 +231,18 @@ layer_notify_valid_changed_cb (GObject * object, GParamSpec * unused
} }
static gboolean 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); gtk_tree_model_get_iter_first ((GtkTreeModel *) model, ret);
while (gtk_list_store_iter_is_valid (model, ret)) { while (gtk_list_store_iter_is_valid (model, ret)) {
GESClip *obj; GESClip *clip2;
gtk_tree_model_get ((GtkTreeModel *) model, ret, 2, &obj, -1); gtk_tree_model_get ((GtkTreeModel *) model, ret, 2, &clip2, -1);
if (obj == object) { if (clip2 == clip) {
g_object_unref (obj); g_object_unref (clip2);
return TRUE; return TRUE;
} }
g_object_unref (obj); g_object_unref (clip2);
gtk_tree_model_iter_next ((GtkTreeModel *) model, ret); gtk_tree_model_iter_next ((GtkTreeModel *) model, ret);
} }
return FALSE; 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 /* this callback is registered for every clip, and updates the
* corresponding duration cell in the model */ * corresponding duration cell in the model */
static void static void
clip_notify_duration_cb (GESClip * object, clip_notify_duration_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app) GParamSpec * arg G_GNUC_UNUSED, App * app)
{ {
GtkTreeIter iter; GtkTreeIter iter;
guint64 duration = 0; guint64 duration = 0;
g_object_get (object, "duration", &duration, NULL); g_object_get (clip, "duration", &duration, NULL);
find_row_for_object (app->model, &iter, object); find_row_for_object (app->model, &iter, clip);
gtk_list_store_set (app->model, &iter, 1, duration, -1); gtk_list_store_set (app->model, &iter, 1, duration, -1);
} }
@ -266,37 +266,37 @@ clip_notify_duration_cb (GESClip * object,
* current selection */ * current selection */
static void static void
filesource_notify_duration_cb (GESClip * object, filesource_notify_duration_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app) GParamSpec * arg G_GNUC_UNUSED, App * app)
{ {
guint64 duration, max_inpoint; guint64 duration, max_inpoint;
duration = GES_TIMELINE_ELEMENT_DURATION (object); duration = GES_TIMELINE_ELEMENT_DURATION (clip);
max_inpoint = GES_TIMELINE_ELEMENT_MAX_DURATION (object) - duration; max_inpoint = GES_TIMELINE_ELEMENT_MAX_DURATION (clip) - duration;
gtk_range_set_value (GTK_RANGE (app->duration), duration); gtk_range_set_value (GTK_RANGE (app->duration), duration);
gtk_range_set_fill_level (GTK_RANGE (app->in_point), max_inpoint); gtk_range_set_fill_level (GTK_RANGE (app->in_point), max_inpoint);
if (max_inpoint < GES_TIMELINE_ELEMENT_INPOINT (object)) if (max_inpoint < GES_TIMELINE_ELEMENT_INPOINT (clip))
g_object_set (object, "in-point", max_inpoint, NULL); g_object_set (clip, "in-point", max_inpoint, NULL);
} }
static void static void
filesource_notify_max_duration_cb (GESClip * object, filesource_notify_max_duration_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app) GParamSpec * arg G_GNUC_UNUSED, App * app)
{ {
gtk_range_set_range (GTK_RANGE (app->duration), 0, (gdouble) 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) 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 static void
filesource_notify_in_point_cb (GESClip * object, filesource_notify_in_point_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app) GParamSpec * arg G_GNUC_UNUSED, App * app)
{ {
gtk_range_set_value (GTK_RANGE (app->in_point), gtk_range_set_value (GTK_RANGE (app->in_point),
GES_TIMELINE_ELEMENT_INPOINT (object)); GES_TIMELINE_ELEMENT_INPOINT (clip));
} }
static void static void
@ -325,66 +325,66 @@ object_count_changed (App * app)
} }
static void static void
title_source_text_changed_cb (GESClip * object, title_source_text_changed_cb (GESClip * clip,
GParamSpec * arg G_GNUC_UNUSED, App * app) GParamSpec * arg G_GNUC_UNUSED, App * app)
{ {
GtkTreeIter iter; GtkTreeIter iter;
gchar *text; gchar *text;
g_object_get (object, "text", &text, NULL); g_object_get (clip, "text", &text, NULL);
if (text) { 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); gtk_list_store_set (app->model, &iter, 0, text, -1);
} }
} }
static void static void
layer_object_added_cb (GESTimelineLayer * layer, GESClip * object, App * app) layer_object_added_cb (GESTimelineLayer * layer, GESClip * clip, App * app)
{ {
GtkTreeIter iter; GtkTreeIter iter;
gchar *description; 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); gtk_list_store_append (app->model, &iter);
if (GES_IS_URI_CLIP (object)) { if (GES_IS_URI_CLIP (clip)) {
g_object_get (G_OBJECT (object), "uri", &description, NULL); g_object_get (G_OBJECT (clip), "uri", &description, NULL);
gtk_list_store_set (app->model, &iter, 0, description, 2, object, -1); gtk_list_store_set (app->model, &iter, 0, description, 2, clip, -1);
} }
else if (GES_IS_TITLE_CLIP (object)) { else if (GES_IS_TITLE_CLIP (clip)) {
gtk_list_store_set (app->model, &iter, 2, object, -1); gtk_list_store_set (app->model, &iter, 2, clip, -1);
g_signal_connect (G_OBJECT (object), "notify::text", g_signal_connect (G_OBJECT (clip), "notify::text",
G_CALLBACK (title_source_text_changed_cb), app); 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)) { else if (GES_IS_TEST_CLIP (clip)) {
gtk_list_store_set (app->model, &iter, 2, object, 0, "Test Source", -1); gtk_list_store_set (app->model, &iter, 2, clip, 0, "Test Source", -1);
} }
else if (GES_IS_BASE_TRANSITION_CLIP (object)) { else if (GES_IS_BASE_TRANSITION_CLIP (clip)) {
gtk_list_store_set (app->model, &iter, 2, object, 0, "Transition", -1); 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); G_CALLBACK (clip_notify_duration_cb), app);
clip_notify_duration_cb (object, NULL, app); clip_notify_duration_cb (clip, NULL, app);
app->n_objects++; app->n_objects++;
object_count_changed (app); object_count_changed (app);
} }
static void static void
layer_object_removed_cb (GESTimelineLayer * layer, GESClip * object, App * app) layer_object_removed_cb (GESTimelineLayer * layer, GESClip * clip, App * app)
{ {
GtkTreeIter iter; 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)) { if (!find_row_for_object (GTK_LIST_STORE (app->model), &iter, clip)) {
g_print ("object deleted but we don't own it"); g_print ("clip deleted but we don't own it");
return; return;
} }
app->n_objects--; app->n_objects--;
@ -394,7 +394,7 @@ layer_object_removed_cb (GESTimelineLayer * layer, GESClip * object, App * app)
} }
static void static void
layer_object_moved_cb (GESClip * layer, GESClip * object, layer_object_moved_cb (GESClip * layer, GESClip * clip,
gint old, gint new, App * app) gint old, gint new, App * app)
{ {
GtkTreeIter a, b; GtkTreeIter a, b;
@ -592,62 +592,64 @@ duration_cell_func (GtkTreeViewColumn * column, GtkCellRenderer * renderer,
/* UI Initialization ********************************************************/ /* UI Initialization ********************************************************/
static void 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); 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); 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); 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 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); 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); filesource_notify_max_duration_cb, app);
} }
static void static void
connect_to_title_source (GESClip * object, App * app) connect_to_title_source (GESClip * clip, App * app)
{ {
GESTitleClip *obj; GESTitleClip *titleclip;
obj = GES_TITLE_CLIP (object); titleclip = GES_TITLE_CLIP (clip);
gtk_combo_box_set_active (app->halign, ges_title_clip_get_halignment (obj)); gtk_combo_box_set_active (app->halign,
gtk_combo_box_set_active (app->valign, ges_title_clip_get_valignment (obj)); ges_title_clip_get_halignment (titleclip));
gtk_entry_set_text (app->text, ges_title_clip_get_text (obj)); 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 static void
disconnect_from_title_source (GESClip * object, App * app) disconnect_from_title_source (GESClip * clip, App * app)
{ {
} }
static void static void
connect_to_test_source (GESClip * object, App * app) connect_to_test_source (GESClip * clip, App * app)
{ {
GObjectClass *klass; GObjectClass *klass;
GParamSpecDouble *pspec; GParamSpecDouble *pspec;
GESTestClip *obj; GESTestClip *testclip;
obj = GES_TEST_CLIP (object); testclip = GES_TEST_CLIP (clip);
gtk_combo_box_set_active (app->background_type, 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); 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")); pspec = G_PARAM_SPEC_DOUBLE (g_object_class_find_property (klass, "volume"));
gtk_range_set_range (GTK_RANGE (app->volume), pspec->minimum, pspec->maximum); 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")); 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_range (app->frequency, pspec->minimum, pspec->maximum);
gtk_spin_button_set_value (app->frequency, 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 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); test_source_notify_volume_changed_cb, app);
} }
static void static void
connect_to_object (GESClip * object, App * app) connect_to_object (GESClip * clip, App * app)
{ {
gchar buf[30]; gchar buf[30];
guint64 duration; guint64 duration;
app->ignore_input = TRUE; 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", g_snprintf (buf, sizeof (buf), "%02u:%02u:%02u.%09u",
GST_TIME_ARGS (duration)); GST_TIME_ARGS (duration));
gtk_entry_set_text (app->seconds, buf); gtk_entry_set_text (app->seconds, buf);
if (GES_IS_URI_CLIP (object)) { if (GES_IS_URI_CLIP (clip)) {
connect_to_filesource (object, app); connect_to_filesource (clip, app);
} else if (GES_IS_TITLE_CLIP (object)) { } else if (GES_IS_TITLE_CLIP (clip)) {
connect_to_title_source (object, app); connect_to_title_source (clip, app);
} else if (GES_IS_TEST_CLIP (object)) { } else if (GES_IS_TEST_CLIP (clip)) {
connect_to_test_source (object, app); connect_to_test_source (clip, app);
} }
app->ignore_input = FALSE; app->ignore_input = FALSE;
} }
static void static void
disconnect_from_object (GESClip * object, App * app) disconnect_from_object (GESClip * clip, App * app)
{ {
if (GES_IS_URI_CLIP (object)) { if (GES_IS_URI_CLIP (clip)) {
disconnect_from_filesource (object, app); disconnect_from_filesource (clip, app);
} else if (GES_IS_TITLE_CLIP (object)) { } else if (GES_IS_TITLE_CLIP (clip)) {
disconnect_from_title_source (object, app); disconnect_from_title_source (clip, app);
} else if (GES_IS_TEST_CLIP (object)) { } else if (GES_IS_TEST_CLIP (clip)) {
disconnect_from_test_source (object, app); disconnect_from_test_source (clip, app);
} }
} }
@ -1018,10 +1020,10 @@ selection_foreach (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter
* iter, gpointer user) * iter, gpointer user)
{ {
select_info *info = (select_info *) user; select_info *info = (select_info *) user;
GESClip *obj; GESClip *clip;
gtk_tree_model_get (model, iter, 2, &obj, -1); gtk_tree_model_get (model, iter, 2, &clip, -1);
info->objects = g_list_append (info->objects, obj); info->objects = g_list_append (info->objects, clip);
info->n++; info->n++;
return; return;
@ -1144,14 +1146,14 @@ app_move_selected_down (App * app)
static void static void
app_add_file (App * app, gchar * uri) app_add_file (App * app, gchar * uri)
{ {
GESClip *obj; GESClip *clip;
GST_DEBUG ("adding file %s", uri); 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), ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER (app->layer),
obj, -1); clip, -1);
} }
static void static void
@ -1184,44 +1186,44 @@ app_launch_project (App * app, gchar * uri)
static void static void
app_add_title (App * app) app_add_title (App * app)
{ {
GESClip *obj; GESClip *clip;
GST_DEBUG ("adding title"); GST_DEBUG ("adding title");
obj = GES_CLIP (ges_title_clip_new ()); clip = GES_CLIP (ges_title_clip_new ());
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), ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER (app->layer),
obj, -1); clip, -1);
} }
static void static void
app_add_test (App * app) app_add_test (App * app)
{ {
GESClip *obj; GESClip *clip;
GST_DEBUG ("adding test"); GST_DEBUG ("adding test");
obj = GES_CLIP (ges_test_clip_new ()); clip = GES_CLIP (ges_test_clip_new ());
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 ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER
(app->layer), obj, -1); (app->layer), clip, -1);
} }
static void static void
app_add_transition (App * app) app_add_transition (App * app)
{ {
GESClip *obj; GESClip *clip;
GST_DEBUG ("adding transition"); GST_DEBUG ("adding transition");
obj = GES_CLIP (ges_transition_clip_new clip = GES_CLIP (ges_transition_clip_new
(GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE)); (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 ges_simple_timeline_layer_add_object (GES_SIMPLE_TIMELINE_LAYER
(app->layer), obj, -1); (app->layer), clip, -1);
} }
static void 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 !*/ * ready to start using it... by solely working with the layer !*/
for (i = 0; i < nbargs / 3; i++) { for (i = 0; i < nbargs / 3; i++) {
GESClip *obj; GESClip *clip;
char *source = argv[i * 3]; char *source = argv[i * 3];
char *arg0 = argv[(i * 3) + 1]; char *arg0 = argv[(i * 3) + 1];
guint64 duration = str_to_time (argv[(i * 3) + 2]); guint64 duration = str_to_time (argv[(i * 3) + 2]);
if (!g_strcmp0 ("+pattern", source)) { if (!g_strcmp0 ("+pattern", source)) {
obj = GES_CLIP (ges_test_clip_new_for_nick (arg0)); clip = GES_CLIP (ges_test_clip_new_for_nick (arg0));
if (!obj) { if (!clip) {
g_error ("%s is an invalid pattern name!\n", arg0); g_error ("%s is an invalid pattern name!\n", arg0);
goto build_failure; 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, g_printf ("Adding <pattern:%s> duration %" GST_TIME_FORMAT "\n", arg0,
GST_TIME_ARGS (duration)); GST_TIME_ARGS (duration));
@ -178,14 +178,14 @@ create_timeline (int nbargs, gchar ** argv, gchar * audio, gchar * video)
goto build_failure; 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"); g_error ("invalid transition type\n");
goto build_failure; 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, g_printf ("Adding <transition:%s> duration %" GST_TIME_FORMAT "\n", arg0,
GST_TIME_ARGS (duration)); GST_TIME_ARGS (duration));
@ -193,9 +193,9 @@ create_timeline (int nbargs, gchar ** argv, gchar * audio, gchar * video)
} }
else if (!g_strcmp0 ("+title", source)) { 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, g_printf ("Adding <title:%s> duration %" GST_TIME_FORMAT "\n", arg0,
GST_TIME_ARGS (duration)); 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]); inpoint = str_to_time (argv[i * 3 + 1]);
obj = GES_CLIP (ges_uri_clip_new (uri)); clip = GES_CLIP (ges_uri_clip_new (uri));
g_object_set (obj, g_object_set (clip,
"in-point", (guint64) inpoint, "duration", (guint64) duration, NULL); "in-point", (guint64) inpoint, "duration", (guint64) duration, NULL);
g_printf ("Adding clip %s inpoint:%" GST_TIME_FORMAT " duration:%" 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 /* Since we're using a GESSimpleTimelineLayer, objects will be automatically
* appended to the end of the layer */ * appended to the end of the layer */
ges_timeline_layer_add_clip (layer, obj); ges_timeline_layer_add_clip (layer, clip);
} }
return timeline; return timeline;