mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-23 10:11:08 +00:00
Code Issues 1 Projects Releases Wiki Activity

Reimplement the timeline editing API

Browse source 
This is implemented on top of a Tree that represents the whole timeline.

SourceClips can not fully overlap anymore and the tests have been
updated to take that into account. Some new tests were added to verify
that behaviour in greater details
This commit is contained in:
Thibault Saunier 2019-03-01 19:32:19 -03:00 committed by Thibault Saunier
parent 7261f714fc
commit a46390ff56
27 changed files with 2814 additions and 2560 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -46,6 +46,10 @@ neighbour_changed_cb (GESClip * clip, GParamSpec * arg G_GNUC_UNUSED,
GESTimelineElement *parent = GESTimelineElement *parent =
ges_timeline_element_get_toplevel_parent (GES_TIMELINE_ELEMENT (clip)); ges_timeline_element_get_toplevel_parent (GES_TIMELINE_ELEMENT (clip));
if (ELEMENT_FLAG_IS_SET (parent, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
return;
}
if (parent) { if (parent) {
GESTimelineElement *prev_topparent = GESTimelineElement *prev_topparent =
ges_timeline_element_get_toplevel_parent (GES_TIMELINE_ELEMENT ges_timeline_element_get_toplevel_parent (GES_TIMELINE_ELEMENT
@ -54,6 +58,11 @@ neighbour_changed_cb (GESClip * clip, GParamSpec * arg G_GNUC_UNUSED,
ges_timeline_element_get_toplevel_parent (GES_TIMELINE_ELEMENT ges_timeline_element_get_toplevel_parent (GES_TIMELINE_ELEMENT
(self->previous_source)); (self->previous_source));
if (ELEMENT_FLAG_IS_SET (prev_topparent, GES_TIMELINE_ELEMENT_SET_SIMPLE) ||
ELEMENT_FLAG_IS_SET (next_topparent, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
return;
}
if (parent == prev_topparent && parent == next_topparent) { if (parent == prev_topparent && parent == next_topparent) {
GST_DEBUG_OBJECT (self, GST_DEBUG_OBJECT (self,
"Moving all inside the same group, nothing to do"); "Moving all inside the same group, nothing to do");
@ -192,3 +201,11 @@ ges_auto_transition_new (GESTrackElement * transition,
return self; return self;
} }
void
ges_auto_transition_update (GESAutoTransition * self)
{
GST_INFO ("Updating info %s",
GES_TIMELINE_ELEMENT_NAME (self->transition_clip));
neighbour_changed_cb (self->previous_clip, NULL, self);
}

1
ges/ges-auto-transition.h
View file

@ -71,6 +71,7 @@ struct _GESAutoTransition
G_GNUC_INTERNAL GType ges_auto_transition_get_type (void) G_GNUC_CONST; G_GNUC_INTERNAL GType ges_auto_transition_get_type (void) G_GNUC_CONST;
G_GNUC_INTERNAL void ges_auto_transition_update (GESAutoTransition *self);
G_GNUC_INTERNAL GESAutoTransition * ges_auto_transition_new (GESTrackElement * transition, G_GNUC_INTERNAL GESAutoTransition * ges_auto_transition_new (GESTrackElement * transition,
GESTrackElement * previous_source, GESTrackElement * previous_source,
GESTrackElement * next_source); GESTrackElement * next_source);

227
ges/ges-clip.c
View file

@ -175,7 +175,6 @@ static gboolean
_set_duration (GESTimelineElement * element, GstClockTime duration) _set_duration (GESTimelineElement * element, GstClockTime duration)
{ {
GList *tmp; GList *tmp;
GESTimeline *timeline;
GESContainer *container = GES_CONTAINER (element); GESContainer *container = GES_CONTAINER (element);
@ -183,17 +182,9 @@ _set_duration (GESTimelineElement * element, GstClockTime duration)
for (tmp = container->children; tmp; tmp = g_list_next (tmp)) { for (tmp = container->children; tmp; tmp = g_list_next (tmp)) {
GESTimelineElement *child = (GESTimelineElement *) tmp->data; GESTimelineElement *child = (GESTimelineElement *) tmp->data;
if (child != container->initiated_move) { if (child != container->initiated_move)
/* Make the snapping happen if in a timeline */
timeline = GES_TIMELINE_ELEMENT_TIMELINE (child);
if (timeline == NULL
|| ELEMENT_FLAG_IS_SET (element, GES_CLIP_IS_SPLITTING)
|| (ges_timeline_trim_object_simple (timeline, child, NULL,
GES_EDGE_END, _START (child) + duration, TRUE) == FALSE)) {
_set_duration0 (GES_TIMELINE_ELEMENT (child), duration); _set_duration0 (GES_TIMELINE_ELEMENT (child), duration);
} }
}
}
container->children_control_mode = GES_CHILDREN_UPDATE; container->children_control_mode = GES_CHILDREN_UPDATE;
return TRUE; return TRUE;
@ -628,9 +619,8 @@ static gboolean
_edit (GESContainer * container, GList * layers, _edit (GESContainer * container, GList * layers,
gint new_layer_priority, GESEditMode mode, GESEdge edge, guint64 position) gint new_layer_priority, GESEditMode mode, GESEdge edge, guint64 position)
{ {
GList *tmp; GESTimeline *timeline = GES_TIMELINE_ELEMENT_TIMELINE (container);
gboolean ret = TRUE; GESTimelineElement *element = GES_TIMELINE_ELEMENT (container);
GESLayer *layer;
if (!G_UNLIKELY (GES_CONTAINER_CHILDREN (container))) { if (!G_UNLIKELY (GES_CONTAINER_CHILDREN (container))) {
GST_WARNING_OBJECT (container, "Trying to edit, but not containing" GST_WARNING_OBJECT (container, "Trying to edit, but not containing"
@ -638,31 +628,35 @@ _edit (GESContainer * container, GList * layers,
return FALSE; return FALSE;
} }
for (tmp = GES_CONTAINER_CHILDREN (container); tmp; tmp = g_list_next (tmp)) { if (!timeline) {
if (GES_IS_SOURCE (tmp->data) || GES_IS_TRANSITION (tmp->data)) { GST_WARNING_OBJECT (container, "Trying to edit, but not in any"
ret &= ges_track_element_edit (tmp->data, layers, mode, edge, position); "timeline.");
break;
}
}
/* Moving to layer */
if (new_layer_priority == -1) {
GST_DEBUG_OBJECT (container, "Not moving new prio %d", new_layer_priority);
} else {
gint priority_offset;
layer = GES_CLIP (container)->priv->layer;
if (layer == NULL) {
GST_WARNING_OBJECT (container, "Not in any layer yet, not moving");
return FALSE; return FALSE;
} }
priority_offset = new_layer_priority - ges_layer_get_priority (layer);
ret &= timeline_context_to_layer (layer->timeline, priority_offset); switch (mode) {
case GES_EDIT_MODE_RIPPLE:
return timeline_ripple_object (timeline, element,
new_layer_priority <
0 ? GES_TIMELINE_ELEMENT_LAYER_PRIORITY (container) :
new_layer_priority, layers, edge, position);
case GES_EDIT_MODE_TRIM:
return timeline_trim_object (timeline, element,
new_layer_priority <
0 ? GES_TIMELINE_ELEMENT_LAYER_PRIORITY (container) :
new_layer_priority, layers, edge, position);
case GES_EDIT_MODE_NORMAL:
return timeline_move_object (timeline, element,
new_layer_priority <
0 ? GES_TIMELINE_ELEMENT_LAYER_PRIORITY (container) :
new_layer_priority, layers, edge, position);
case GES_EDIT_MODE_ROLL:
return timeline_roll_object (timeline, element, layers, edge, position);
case GES_EDIT_MODE_SLIDE:
GST_ERROR ("Sliding not implemented.");
return FALSE;
} }
return FALSE;
return ret;
} }
static void static void
@ -1012,23 +1006,6 @@ ges_clip_set_layer (GESClip * clip, GESLayer * layer)
g_object_notify_by_pspec (G_OBJECT (clip), properties[PROP_LAYER]); g_object_notify_by_pspec (G_OBJECT (clip), properties[PROP_LAYER]);
} }
/**
* ges_clip_get_layer_priority:
* @clip: The clip to get the layer priority from
*
* Returns: The priority of the layer @clip is in, -1 if not in a layer.
*/
guint32
ges_clip_get_layer_priority (GESClip * clip)
{
g_return_val_if_fail (GES_IS_CLIP (clip), -1);
if (clip->priv->layer == NULL)
return -1;
return ges_layer_get_priority (clip->priv->layer);
}
/** /**
* ges_clip_set_moving_from_layer: * ges_clip_set_moving_from_layer:
* @clip: a #GESClip * @clip: a #GESClip
@ -1088,6 +1065,19 @@ ges_clip_move_to_layer (GESClip * clip, GESLayer * layer)
g_return_val_if_fail (GES_IS_CLIP (clip), FALSE); g_return_val_if_fail (GES_IS_CLIP (clip), FALSE);
g_return_val_if_fail (GES_IS_LAYER (layer), FALSE); g_return_val_if_fail (GES_IS_LAYER (layer), FALSE);
ELEMENT_SET_FLAG (clip, GES_CLIP_IS_MOVING);
if (layer->timeline
&& !timeline_tree_can_move_element (timeline_get_tree (layer->timeline),
GES_TIMELINE_ELEMENT (clip),
ges_layer_get_priority (layer),
GES_TIMELINE_ELEMENT_START (clip),
GES_TIMELINE_ELEMENT_DURATION (clip), NULL)) {
GST_INFO_OBJECT (layer, "Clip %" GES_FORMAT " can't move to layer %d",
GES_ARGS (clip), ges_layer_get_priority (layer));
ELEMENT_UNSET_FLAG (clip, GES_CLIP_IS_MOVING);
return FALSE;
}
current_layer = clip->priv->layer; current_layer = clip->priv->layer;
if (current_layer == NULL) { if (current_layer == NULL) {
@ -1099,11 +1089,11 @@ ges_clip_move_to_layer (GESClip * clip, GESLayer * layer)
GST_DEBUG_OBJECT (clip, "moving to layer %p, priority: %d", layer, GST_DEBUG_OBJECT (clip, "moving to layer %p, priority: %d", layer,
ges_layer_get_priority (layer)); ges_layer_get_priority (layer));
ELEMENT_SET_FLAG (clip, GES_CLIP_IS_MOVING);
gst_object_ref (clip); gst_object_ref (clip);
ret = ges_layer_remove_clip (current_layer, clip); ret = ges_layer_remove_clip (current_layer, clip);
if (!ret) { if (!ret) {
ELEMENT_UNSET_FLAG (clip, GES_CLIP_IS_MOVING);
gst_object_unref (clip); gst_object_unref (clip);
return FALSE; return FALSE;
} }
@ -1418,16 +1408,9 @@ ges_clip_split (GESClip * clip, guint64 position)
position - start + inpoint); position - start + inpoint);
} }
ELEMENT_SET_FLAG (clip, GES_CLIP_IS_SPLITTING); ELEMENT_SET_FLAG (clip, GES_TIMELINE_ELEMENT_SET_SIMPLE);
_set_duration0 (GES_TIMELINE_ELEMENT (clip), old_duration); _set_duration0 (GES_TIMELINE_ELEMENT (clip), old_duration);
ELEMENT_UNSET_FLAG (clip, GES_CLIP_IS_SPLITTING); ELEMENT_UNSET_FLAG (clip, GES_TIMELINE_ELEMENT_SET_SIMPLE);
if (GES_TIMELINE_ELEMENT_TIMELINE (clip)) {
for (tmp = GES_CONTAINER_CHILDREN (new_object); tmp; tmp = tmp->next) {
timeline_create_transitions (GES_TIMELINE_ELEMENT_TIMELINE (tmp->data),
tmp->data);
}
}
return new_object; return new_object;
} }
@ -1466,134 +1449,40 @@ ges_clip_get_supported_formats (GESClip * clip)
gboolean gboolean
_ripple (GESTimelineElement * element, GstClockTime start) _ripple (GESTimelineElement * element, GstClockTime start)
{ {
gboolean ret = TRUE; return ges_container_edit (GES_CONTAINER (element), NULL,
GESTimeline *timeline; ges_timeline_element_get_layer_priority (element),
GESClip *clip = GES_CLIP (element); GES_EDIT_MODE_RIPPLE, GES_EDGE_NONE, start);
timeline = ges_layer_get_timeline (clip->priv->layer);
if (timeline == NULL) {
GST_DEBUG ("Not in a timeline yet");
return FALSE;
}
if (start > _END (element))
start = _END (element);
if (GES_CONTAINER_CHILDREN (element)) {
GESTrackElement *track_element =
GES_TRACK_ELEMENT (GES_CONTAINER_CHILDREN (element)->data);
ret = timeline_ripple_object (timeline, track_element, NULL, GES_EDGE_NONE,
start);
}
return ret;
} }
static gboolean static gboolean
_ripple_end (GESTimelineElement * element, GstClockTime end) _ripple_end (GESTimelineElement * element, GstClockTime end)
{ {
gboolean ret = TRUE; return ges_container_edit (GES_CONTAINER (element), NULL,
GESTimeline *timeline; ges_timeline_element_get_layer_priority (element),
GESClip *clip = GES_CLIP (element); GES_EDIT_MODE_RIPPLE, GES_EDGE_END, end);
timeline = ges_layer_get_timeline (clip->priv->layer);
if (timeline == NULL) {
GST_DEBUG ("Not in a timeline yet");
return FALSE;
}
if (GES_CONTAINER_CHILDREN (element)) {
GESTrackElement *track_element =
GES_TRACK_ELEMENT (GES_CONTAINER_CHILDREN (element)->data);
ret = timeline_ripple_object (timeline, track_element, NULL, GES_EDGE_END,
end);
}
return ret;
} }
gboolean gboolean
_roll_start (GESTimelineElement * element, GstClockTime start) _roll_start (GESTimelineElement * element, GstClockTime start)
{ {
gboolean ret = TRUE; return ges_container_edit (GES_CONTAINER (element), NULL,
GESTimeline *timeline; ges_timeline_element_get_layer_priority (element),
GES_EDIT_MODE_ROLL, GES_EDGE_START, start);
GESClip *clip = GES_CLIP (element);
timeline = ges_layer_get_timeline (clip->priv->layer);
if (timeline == NULL) {
GST_DEBUG ("Not in a timeline yet");
return FALSE;
}
if (GES_CONTAINER_CHILDREN (element)) {
GESTrackElement *track_element =
GES_TRACK_ELEMENT (GES_CONTAINER_CHILDREN (element)->data);
ret = timeline_roll_object (timeline, track_element, NULL, GES_EDGE_START,
start);
}
return ret;
} }
gboolean gboolean
_roll_end (GESTimelineElement * element, GstClockTime end) _roll_end (GESTimelineElement * element, GstClockTime end)
{ {
gboolean ret = TRUE; return ges_container_edit (GES_CONTAINER (element), NULL,
GESTimeline *timeline; ges_timeline_element_get_layer_priority (element),
GES_EDIT_MODE_ROLL, GES_EDGE_END, end);
GESClip *clip = GES_CLIP (element);
timeline = ges_layer_get_timeline (clip->priv->layer);
if (timeline == NULL) {
GST_DEBUG ("Not in a timeline yet");
return FALSE;
}
if (GES_CONTAINER_CHILDREN (element)) {
GESTrackElement *track_element =
GES_TRACK_ELEMENT (GES_CONTAINER_CHILDREN (element)->data);
ret = timeline_roll_object (timeline, track_element,
NULL, GES_EDGE_END, end);
}
return ret;
} }
gboolean gboolean
_trim (GESTimelineElement * element, GstClockTime start) _trim (GESTimelineElement * element, GstClockTime start)
{ {
gboolean ret = TRUE; return ges_container_edit (GES_CONTAINER (element), NULL, -1,
GESTimeline *timeline; GES_EDIT_MODE_TRIM, GES_EDGE_START, start);
GESClip *clip = GES_CLIP (element);
timeline = ges_layer_get_timeline (clip->priv->layer);
if (timeline == NULL) {
GST_DEBUG ("Not in a timeline yet");
return FALSE;
}
if (GES_CONTAINER_CHILDREN (element)) {
GESTrackElement *track_element =
GES_TRACK_ELEMENT (GES_CONTAINER_CHILDREN (element)->data);
GST_DEBUG_OBJECT (element, "Trimming child: %" GST_PTR_FORMAT,
track_element);
ret = timeline_trim_object (timeline, track_element, NULL, GES_EDGE_START,
start);
}
return ret;
} }
/** /**

2
ges/ges-clip.h
View file

@ -163,8 +163,6 @@ GES_API
GESLayer* ges_clip_get_layer (GESClip *clip); GESLayer* ges_clip_get_layer (GESClip *clip);
GES_API GES_API
gboolean ges_clip_move_to_layer (GESClip *clip, GESLayer *layer); gboolean ges_clip_move_to_layer (GESClip *clip, GESLayer *layer);
GES_API
guint32 ges_clip_get_layer_priority (GESClip * clip);
/**************************************************** /****************************************************
* Effects * * Effects *

21
ges/ges-container.c
View file

@ -524,10 +524,14 @@ _child_start_changed_cb (GESTimelineElement * child,
GESContainerPrivate *priv = container->priv; GESContainerPrivate *priv = container->priv;
GESTimelineElement *element = GES_TIMELINE_ELEMENT (container); GESTimelineElement *element = GES_TIMELINE_ELEMENT (container);
GESChildrenControlMode pmode = container->children_control_mode;
map = g_hash_table_lookup (priv->mappings, child); map = g_hash_table_lookup (priv->mappings, child);
g_assert (map); g_assert (map);
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
container->children_control_mode = GES_CHILDREN_UPDATE_ALL_VALUES;
switch (container->children_control_mode) { switch (container->children_control_mode) {
case GES_CHILDREN_IGNORE_NOTIFIES: case GES_CHILDREN_IGNORE_NOTIFIES:
return; return;
@ -540,8 +544,8 @@ _child_start_changed_cb (GESTimelineElement * child,
_DURATION (container) = _END (container) - start; _DURATION (container) = _END (container) - start;
_START (container) = start; _START (container) = start;
GST_DEBUG_OBJECT (container, "Child move made us " GST_DEBUG_OBJECT (container, "Child move made us move %" GES_FORMAT,
"move to %" GST_TIME_FORMAT, GST_TIME_ARGS (_START (container))); GES_ARGS (container));
g_object_notify (G_OBJECT (container), "start"); g_object_notify (G_OBJECT (container), "start");
} }
@ -560,6 +564,9 @@ _child_start_changed_cb (GESTimelineElement * child,
default: default:
break; break;
} }
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
container->children_control_mode = pmode;
} }
static void static void
@ -577,7 +584,8 @@ _child_inpoint_changed_cb (GESTimelineElement * child,
map = g_hash_table_lookup (priv->mappings, child); map = g_hash_table_lookup (priv->mappings, child);
g_assert (map); g_assert (map);
if (container->children_control_mode == GES_CHILDREN_UPDATE_OFFSETS) { if (container->children_control_mode == GES_CHILDREN_UPDATE_OFFSETS
|| ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
map->inpoint_offset = _START (container) - _START (child); map->inpoint_offset = _START (container) - _START (child);
return; return;
@ -599,10 +607,14 @@ _child_duration_changed_cb (GESTimelineElement * child,
GstClockTime end = 0; GstClockTime end = 0;
GESContainerPrivate *priv = container->priv; GESContainerPrivate *priv = container->priv;
GESTimelineElement *element = GES_TIMELINE_ELEMENT (container); GESTimelineElement *element = GES_TIMELINE_ELEMENT (container);
GESChildrenControlMode pmode = container->children_control_mode;
if (container->children_control_mode == GES_CHILDREN_IGNORE_NOTIFIES) if (container->children_control_mode == GES_CHILDREN_IGNORE_NOTIFIES)
return; return;
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
container->children_control_mode = GES_CHILDREN_UPDATE_ALL_VALUES;
map = g_hash_table_lookup (priv->mappings, child); map = g_hash_table_lookup (priv->mappings, child);
g_assert (map); g_assert (map);
@ -632,6 +644,9 @@ _child_duration_changed_cb (GESTimelineElement * child,
default: default:
break; break;
} }
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
container->children_control_mode = pmode;
} }
/**************************************************** /****************************************************

104
ges/ges-group.c
View file

@ -255,11 +255,7 @@ _child_group_priority_changed (GESTimelineElement * child,
static gboolean static gboolean
_trim (GESTimelineElement * group, GstClockTime start) _trim (GESTimelineElement * group, GstClockTime start)
{ {
GList *tmp;
GstClockTime last_child_end = 0, oldstart = _START (group);
GESContainer *container = GES_CONTAINER (group);
GESTimeline *timeline = GES_TIMELINE_ELEMENT_TIMELINE (group); GESTimeline *timeline = GES_TIMELINE_ELEMENT_TIMELINE (group);
gboolean ret = TRUE, expending = (start < _START (group));
if (timeline == NULL) { if (timeline == NULL) {
GST_DEBUG ("Not in a timeline yet"); GST_DEBUG ("Not in a timeline yet");
@ -267,40 +263,9 @@ _trim (GESTimelineElement * group, GstClockTime start)
return FALSE; return FALSE;
} }
container->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES; return timeline_tree_trim (timeline_get_tree (timeline), group,
for (tmp = GES_CONTAINER_CHILDREN (group); tmp; tmp = tmp->next) { 0, GST_CLOCK_DIFF (start, _START (group)), GES_EDGE_START,
GESTimelineElement *child = tmp->data; ges_timeline_get_snapping_distance (timeline));
if (expending) {
/* If the start is bigger, we do not touch it (in case we are expending) */
if (_START (child) > oldstart) {
GST_DEBUG_OBJECT (child, "Skipping as not at begining of the group");
continue;
}
ret &= ges_timeline_element_trim (child, start);
} else {
if (start > _END (child))
ret &= ges_timeline_element_trim (child, _END (child));
else if (_START (child) < start && _DURATION (child))
ret &= ges_timeline_element_trim (child, start);
}
}
for (tmp = GES_CONTAINER_CHILDREN (group); tmp; tmp = tmp->next) {
if (_DURATION (tmp->data))
last_child_end =
MAX (GES_TIMELINE_ELEMENT_END (tmp->data), last_child_end);
}
GES_GROUP (group)->priv->setting_value = TRUE;
_set_start0 (group, start);
_set_duration0 (group, last_child_end - start);
GES_GROUP (group)->priv->setting_value = FALSE;
container->children_control_mode = GES_CHILDREN_UPDATE;
return ret;
} }
static gboolean static gboolean
@ -309,38 +274,44 @@ _set_priority (GESTimelineElement * element, guint32 priority)
GList *tmp, *layers; GList *tmp, *layers;
gint diff = priority - _PRIORITY (element); gint diff = priority - _PRIORITY (element);
GESContainer *container = GES_CONTAINER (element); GESContainer *container = GES_CONTAINER (element);
GESTimeline *timeline = GES_TIMELINE_ELEMENT_TIMELINE (element);
if (GES_GROUP (element)->priv->setting_value == TRUE) if (GES_GROUP (element)->priv->setting_value == TRUE)
return TRUE; return TRUE;
container->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES; container->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES;
layers = GES_TIMELINE_ELEMENT_TIMELINE (element) ? layers = GES_TIMELINE_ELEMENT_TIMELINE (element) ?
GES_TIMELINE_ELEMENT_TIMELINE (element)->layers : NULL; GES_TIMELINE_ELEMENT_TIMELINE (element)->layers : NULL;
if (layers == NULL) { if (layers == NULL) {
GST_WARNING_OBJECT (element, "Not any layer in the timeline, not doing" GST_WARNING_OBJECT (element, "Not any layer in the timeline, not doing"
"anything, timeline: %" GST_PTR_FORMAT, "anything, timeline: %" GST_PTR_FORMAT,
GES_TIMELINE_ELEMENT_TIMELINE (element)); GES_TIMELINE_ELEMENT_TIMELINE (element));
return FALSE; return FALSE;
} else if (priority + GES_CONTAINER_HEIGHT (container) - 1 >
g_list_length (layers)) {
GST_WARNING_OBJECT (container, "Trying to move to a layer outside of"
"the timeline layers");
return FALSE;
} }
for (tmp = GES_CONTAINER_CHILDREN (element); tmp; tmp = tmp->next) { for (tmp = GES_CONTAINER_CHILDREN (element); tmp; tmp = tmp->next) {
GESTimelineElement *child = tmp->data; GESTimelineElement *child = tmp->data;
if (child != container->initiated_move) { if (child != container->initiated_move
|| ELEMENT_FLAG_IS_SET (container, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
if (GES_IS_CLIP (child)) { if (GES_IS_CLIP (child)) {
guint32 layer_prio = GES_TIMELINE_ELEMENT_LAYER_PRIORITY (child) + diff; guint32 layer_prio = GES_TIMELINE_ELEMENT_LAYER_PRIORITY (child) + diff;
GESLayer *layer =
g_list_nth_data (GES_TIMELINE_GET_LAYERS (timeline), layer_prio);
GST_DEBUG_OBJECT (child, "moving from layer: %i to %i", if (layer == NULL) {
GES_TIMELINE_ELEMENT_LAYER_PRIORITY (child), layer_prio); do {
ges_clip_move_to_layer (GES_CLIP (child), layer = ges_timeline_append_layer (timeline);
g_list_nth_data (layers, layer_prio)); } while (ges_layer_get_priority (layer) < layer_prio);
}
GST_DEBUG ("%" GES_FORMAT "moving from layer: %i to %i",
GES_ARGS (child), GES_TIMELINE_ELEMENT_LAYER_PRIORITY (child),
layer_prio);
ges_clip_move_to_layer (GES_CLIP (child), g_list_nth_data (layers,
layer_prio));
} else if (GES_IS_GROUP (child)) { } else if (GES_IS_GROUP (child)) {
GST_DEBUG_OBJECT (child, "moving from %i to %i", GST_DEBUG_OBJECT (child, "moving from %i to %i",
_PRIORITY (child), diff + _PRIORITY (child)); _PRIORITY (child), diff + _PRIORITY (child));
@ -358,28 +329,35 @@ _set_start (GESTimelineElement * element, GstClockTime start)
{ {
GList *tmp; GList *tmp;
gint64 diff = start - _START (element); gint64 diff = start - _START (element);
GESTimeline *timeline;
GESContainer *container = GES_CONTAINER (element); GESContainer *container = GES_CONTAINER (element);
GESTimelineElement *toplevel =
ges_timeline_element_get_toplevel_parent (element);;
gst_object_unref (toplevel);
if (GES_GROUP (element)->priv->setting_value == TRUE) if (GES_GROUP (element)->priv->setting_value == TRUE)
/* Let GESContainer update itself */ /* Let GESContainer update itself */
return GES_TIMELINE_ELEMENT_CLASS (parent_class)->set_start (element, return GES_TIMELINE_ELEMENT_CLASS (parent_class)->set_start (element,
start); start);
if (ELEMENT_FLAG_IS_SET (element, GES_TIMELINE_ELEMENT_SET_SIMPLE) ||
ELEMENT_FLAG_IS_SET (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
container->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES; container->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES;
for (tmp = GES_CONTAINER_CHILDREN (element); tmp; tmp = tmp->next) { for (tmp = GES_CONTAINER_CHILDREN (element); tmp; tmp = tmp->next)
GESTimelineElement *child = (GESTimelineElement *) tmp->data; _set_start0 (tmp->data, _START (tmp->data) + diff);
if (child != container->initiated_move &&
(_END (child) > _START (element) || _END (child) > start)) {
_set_start0 (child, _START (child) + diff);
}
}
container->children_control_mode = GES_CHILDREN_UPDATE; container->children_control_mode = GES_CHILDREN_UPDATE;
return TRUE; return TRUE;
} }
timeline = GES_TIMELINE_ELEMENT_TIMELINE (element);
if (timeline)
return ges_timeline_move_object_simple (timeline, element, NULL,
GES_EDGE_NONE, start);
return TRUE;
}
static gboolean static gboolean
_set_inpoint (GESTimelineElement * element, GstClockTime inpoint) _set_inpoint (GESTimelineElement * element, GstClockTime inpoint)
{ {
@ -399,6 +377,12 @@ _set_duration (GESTimelineElement * element, GstClockTime duration)
return GES_TIMELINE_ELEMENT_CLASS (parent_class)->set_duration (element, return GES_TIMELINE_ELEMENT_CLASS (parent_class)->set_duration (element,
duration); duration);
if (element->timeline
&& !timeline_tree_can_move_element (timeline_get_tree (element->timeline),
element, _PRIORITY (element), element->start, duration, NULL)) {
return FALSE;
}
if (container->initiated_move == NULL) { if (container->initiated_move == NULL) {
gboolean expending = (_DURATION (element) < duration); gboolean expending = (_DURATION (element) < duration);
@ -471,6 +455,7 @@ _child_added (GESContainer * group, GESTimelineElement * child)
} }
priv->setting_value = TRUE; priv->setting_value = TRUE;
ELEMENT_SET_FLAG (group, GES_TIMELINE_ELEMENT_SET_SIMPLE);
if (first_child_start != GES_TIMELINE_ELEMENT_START (group)) { if (first_child_start != GES_TIMELINE_ELEMENT_START (group)) {
group->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES; group->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES;
_set_start0 (GES_TIMELINE_ELEMENT (group), first_child_start); _set_start0 (GES_TIMELINE_ELEMENT (group), first_child_start);
@ -480,6 +465,7 @@ _child_added (GESContainer * group, GESTimelineElement * child)
_set_duration0 (GES_TIMELINE_ELEMENT (group), _set_duration0 (GES_TIMELINE_ELEMENT (group),
last_child_end - first_child_start); last_child_end - first_child_start);
} }
ELEMENT_UNSET_FLAG (group, GES_TIMELINE_ELEMENT_SET_SIMPLE);
priv->setting_value = FALSE; priv->setting_value = FALSE;
group->children_control_mode = GES_CHILDREN_UPDATE; group->children_control_mode = GES_CHILDREN_UPDATE;
@ -561,12 +547,14 @@ _child_removed (GESContainer * group, GESTimelineElement * child)
} }
priv->setting_value = TRUE; priv->setting_value = TRUE;
ELEMENT_SET_FLAG (group, GES_TIMELINE_ELEMENT_SET_SIMPLE);
first_child_start = GES_TIMELINE_ELEMENT_START (children->data); first_child_start = GES_TIMELINE_ELEMENT_START (children->data);
if (first_child_start > GES_TIMELINE_ELEMENT_START (group)) { if (first_child_start > GES_TIMELINE_ELEMENT_START (group)) {
group->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES; group->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES;
_set_start0 (GES_TIMELINE_ELEMENT (group), first_child_start); _set_start0 (GES_TIMELINE_ELEMENT (group), first_child_start);
group->children_control_mode = GES_CHILDREN_UPDATE; group->children_control_mode = GES_CHILDREN_UPDATE;
} }
ELEMENT_UNSET_FLAG (group, GES_TIMELINE_ELEMENT_SET_SIMPLE);
priv->setting_value = FALSE; priv->setting_value = FALSE;
} }

49
ges/ges-internal.h
View file

@ -30,6 +30,7 @@
#include "ges-asset.h" #include "ges-asset.h"
#include "ges-base-xml-formatter.h" #include "ges-base-xml-formatter.h"
#include "ges-timeline-tree.h"
G_BEGIN_DECLS G_BEGIN_DECLS
@ -50,7 +51,9 @@ GST_DEBUG_CATEGORY_EXTERN (_ges_debug);
#define _DURATION(obj) GES_TIMELINE_ELEMENT_DURATION (obj) #define _DURATION(obj) GES_TIMELINE_ELEMENT_DURATION (obj)
#define _MAXDURATION(obj) GES_TIMELINE_ELEMENT_MAX_DURATION (obj) #define _MAXDURATION(obj) GES_TIMELINE_ELEMENT_MAX_DURATION (obj)
#define _PRIORITY(obj) GES_TIMELINE_ELEMENT_PRIORITY (obj) #define _PRIORITY(obj) GES_TIMELINE_ELEMENT_PRIORITY (obj)
#ifndef _END
#define _END(obj) (_START (obj) + _DURATION (obj)) #define _END(obj) (_START (obj) + _DURATION (obj))
#endif
#define _set_start0 ges_timeline_element_set_start #define _set_start0 ges_timeline_element_set_start
#define _set_inpoint0 ges_timeline_element_set_inpoint #define _set_inpoint0 ges_timeline_element_set_inpoint
#define _set_duration0 ges_timeline_element_set_duration #define _set_duration0 ges_timeline_element_set_duration
@ -60,16 +63,22 @@ GST_DEBUG_CATEGORY_EXTERN (_ges_debug);
"s<%p>" \ "s<%p>" \
" [ %" GST_TIME_FORMAT \ " [ %" GST_TIME_FORMAT \
" (%" GST_TIME_FORMAT \ " (%" GST_TIME_FORMAT \
") - %" GST_TIME_FORMAT "]" ") - %" GST_TIME_FORMAT "(%" GST_TIME_FORMAT") layer: %" G_GINT32_FORMAT "] "
#define GES_TIMELINE_ELEMENT_ARGS(element) \ #define GES_TIMELINE_ELEMENT_ARGS(element) \
GES_TIMELINE_ELEMENT_NAME(element), element, \ GES_TIMELINE_ELEMENT_NAME(element), element, \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_START(element)), \ GST_TIME_ARGS(GES_TIMELINE_ELEMENT_START(element)), \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_INPOINT(element)), \ GST_TIME_ARGS(GES_TIMELINE_ELEMENT_INPOINT(element)), \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_DURATION(element)) GST_TIME_ARGS(GES_TIMELINE_ELEMENT_DURATION(element)), \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_MAX_DURATION(element)), \
GES_TIMELINE_ELEMENT_LAYER_PRIORITY(element)
#define GES_FORMAT GES_TIMELINE_ELEMENT_FORMAT
#define GES_ARGS GES_TIMELINE_ELEMENT_ARGS
G_GNUC_INTERNAL gboolean G_GNUC_INTERNAL gboolean
timeline_ripple_object (GESTimeline *timeline, GESTrackElement *obj, timeline_ripple_object (GESTimeline *timeline, GESTimelineElement *obj,
gint new_layer_priority,
GList * layers, GESEdge edge, GList * layers, GESEdge edge,
guint64 position); guint64 position);
@ -78,26 +87,26 @@ timeline_slide_object (GESTimeline *timeline, GESTrackElement *obj,
GList * layers, GESEdge edge, guint64 position); GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean G_GNUC_INTERNAL gboolean
timeline_roll_object (GESTimeline *timeline, GESTrackElement *obj, timeline_roll_object (GESTimeline *timeline, GESTimelineElement *obj,
GList * layers, GESEdge edge, guint64 position); GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean G_GNUC_INTERNAL gboolean
timeline_trim_object (GESTimeline *timeline, GESTrackElement * object, timeline_trim_object (GESTimeline *timeline, GESTimelineElement * object,
GList * layers, GESEdge edge, guint64 position); guint32 new_layer_priority, GList * layers, GESEdge edge,
guint64 position);
G_GNUC_INTERNAL gboolean G_GNUC_INTERNAL gboolean
ges_timeline_trim_object_simple (GESTimeline * timeline, GESTimelineElement * obj, ges_timeline_trim_object_simple (GESTimeline * timeline, GESTimelineElement * obj,
GList * layers, GESEdge edge, guint64 position, gboolean snapping); guint32 new_layer_priority, GList * layers, GESEdge edge,
guint64 position, gboolean snapping);
G_GNUC_INTERNAL gboolean G_GNUC_INTERNAL gboolean
ges_timeline_move_object_simple (GESTimeline * timeline, GESTimelineElement * object, ges_timeline_move_object_simple (GESTimeline * timeline, GESTimelineElement * object,
GList * layers, GESEdge edge, guint64 position); GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean G_GNUC_INTERNAL gboolean
timeline_move_object (GESTimeline *timeline, GESTrackElement * object, timeline_move_object (GESTimeline *timeline, GESTimelineElement * object,
GList * layers, GESEdge edge, guint64 position); guint32 new_layer_priority, GList * layers, GESEdge edge,
guint64 position);
G_GNUC_INTERNAL gboolean
timeline_context_to_layer (GESTimeline *timeline, gint offset);
G_GNUC_INTERNAL void G_GNUC_INTERNAL void
timeline_add_group (GESTimeline *timeline, timeline_add_group (GESTimeline *timeline,
@ -121,6 +130,14 @@ gboolean
timeline_remove_element (GESTimeline *timeline, timeline_remove_element (GESTimeline *timeline,
GESTimelineElement *element); GESTimelineElement *element);
G_GNUC_INTERNAL
GNode *
timeline_get_tree (GESTimeline *timeline);
G_GNUC_INTERNAL
void
timeline_update_transition (GESTimeline *timeline);
G_GNUC_INTERNAL G_GNUC_INTERNAL
void void
timeline_fill_gaps (GESTimeline *timeline); timeline_fill_gaps (GESTimeline *timeline);
@ -396,9 +413,8 @@ G_GNUC_INTERNAL GESVideoTestSource * ges_video_test_source_new (void);
****************************************************/ ****************************************************/
typedef enum typedef enum
{ {
GES_CLIP_IS_SPLITTING = (1 << 0), GES_CLIP_IS_MOVING = (1 << 0),
GES_CLIP_IS_MOVING = (1 << 1), GES_TIMELINE_ELEMENT_SET_SIMPLE = (1 << 1),
GES_TIMELINE_ELEMENT_SET_SIMPLE = (1 << 2),
} GESTimelineElementFlags; } GESTimelineElementFlags;
G_GNUC_INTERNAL gdouble ges_timeline_element_get_media_duration_factor(GESTimelineElement *self); G_GNUC_INTERNAL gdouble ges_timeline_element_get_media_duration_factor(GESTimelineElement *self);
@ -406,9 +422,6 @@ G_GNUC_INTERNAL GESTimelineElement * ges_timeline_element_get_copied_from (GESTi
G_GNUC_INTERNAL GESTimelineElementFlags ges_timeline_element_flags (GESTimelineElement *self); G_GNUC_INTERNAL GESTimelineElementFlags ges_timeline_element_flags (GESTimelineElement *self);
G_GNUC_INTERNAL void ges_timeline_element_set_flags (GESTimelineElement *self, GESTimelineElementFlags flags); G_GNUC_INTERNAL void ges_timeline_element_set_flags (GESTimelineElement *self, GESTimelineElementFlags flags);
/* FIXME: Provide a clean way to get layer prio generically */
G_GNUC_INTERNAL gint32 _layer_priority (GESTimelineElement * element);
#define ELEMENT_FLAGS(obj) (ges_timeline_element_flags (GES_TIMELINE_ELEMENT(obj))) #define ELEMENT_FLAGS(obj) (ges_timeline_element_flags (GES_TIMELINE_ELEMENT(obj)))
#define ELEMENT_SET_FLAG(obj,flag) (ges_timeline_element_set_flags(GES_TIMELINE_ELEMENT(obj), (ELEMENT_FLAGS(obj) | (flag)))) #define ELEMENT_SET_FLAG(obj,flag) (ges_timeline_element_set_flags(GES_TIMELINE_ELEMENT(obj), (ELEMENT_FLAGS(obj) | (flag))))
#define ELEMENT_UNSET_FLAG(obj,flag) (ges_timeline_element_set_flags(GES_TIMELINE_ELEMENT(obj), (ELEMENT_FLAGS(obj) & ~(flag)))) #define ELEMENT_UNSET_FLAG(obj,flag) (ges_timeline_element_set_flags(GES_TIMELINE_ELEMENT(obj), (ELEMENT_FLAGS(obj) & ~(flag))))

11
ges/ges-layer.c
View file

@ -666,6 +666,17 @@ ges_layer_add_clip (GESLayer * layer, GESClip * clip)
/* emit 'clip-added' */ /* emit 'clip-added' */
g_signal_emit (layer, ges_layer_signals[OBJECT_ADDED], 0, clip); g_signal_emit (layer, ges_layer_signals[OBJECT_ADDED], 0, clip);
if (!ELEMENT_FLAG_IS_SET (clip, GES_CLIP_IS_MOVING) && layer->timeline
&& !timeline_tree_can_move_element (timeline_get_tree (layer->timeline),
GES_TIMELINE_ELEMENT (clip),
GES_TIMELINE_ELEMENT_LAYER_PRIORITY (clip),
GES_TIMELINE_ELEMENT_START (clip),
GES_TIMELINE_ELEMENT_DURATION (clip), NULL)) {
GST_INFO_OBJECT (layer, "Clip %" GES_FORMAT, GES_ARGS (clip));
ges_layer_remove_clip_internal (layer, clip, TRUE);
return FALSE;
}
return TRUE; return TRUE;
} }

59
ges/ges-source-clip.c
View file

@ -49,43 +49,41 @@ G_DEFINE_TYPE_WITH_PRIVATE (GESSourceClip, ges_source_clip, GES_TYPE_CLIP);
static gboolean static gboolean
_set_start (GESTimelineElement * element, GstClockTime start) _set_start (GESTimelineElement * element, GstClockTime start)
{ {
GList *tmp; GESTimelineElement *toplevel =
GESTimeline *timeline; ges_timeline_element_get_toplevel_parent (element);
GESContainer *container = GES_CONTAINER (element);
GstClockTime rollback_start = GES_TIMELINE_ELEMENT_START (element);
GST_DEBUG_OBJECT (element, "Setting children start, (initiated_move: %" gst_object_unref (toplevel);
GST_PTR_FORMAT ")", container->initiated_move); if (element->timeline
&& !ELEMENT_FLAG_IS_SET (element, GES_TIMELINE_ELEMENT_SET_SIMPLE)
element->start = start; && !ELEMENT_FLAG_IS_SET (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
g_object_notify (G_OBJECT (element), "start"); ges_timeline_move_object_simple (element->timeline, element, NULL,
container->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES; GES_EDGE_NONE, start);
for (tmp = container->children; tmp; tmp = g_list_next (tmp)) {
GESTimelineElement *child = (GESTimelineElement *) tmp->data;
if (child != container->initiated_move) {
/* Make the snapping happen if in a timeline */
timeline = GES_TIMELINE_ELEMENT_TIMELINE (child);
if (timeline && !container->initiated_move) {
if (!ges_timeline_move_object_simple (timeline, child, NULL,
GES_EDGE_NONE, start)) {
for (tmp = container->children; tmp; tmp = g_list_next (tmp))
ges_timeline_element_set_start (tmp->data, rollback_start);
element->start = rollback_start;
g_object_notify (G_OBJECT (element), "start");
container->children_control_mode = GES_CHILDREN_UPDATE;
return FALSE; return FALSE;
} }
return
GES_TIMELINE_ELEMENT_CLASS (ges_source_clip_parent_class)->set_start
(element, start);
} }
_set_start0 (GES_TIMELINE_ELEMENT (child), start); static gboolean
} _set_duration (GESTimelineElement * element, GstClockTime duration)
{
GESTimelineElement *toplevel =
ges_timeline_element_get_toplevel_parent (element);
gst_object_unref (toplevel);
if (element->timeline
&& !ELEMENT_FLAG_IS_SET (element, GES_TIMELINE_ELEMENT_SET_SIMPLE)
&& !ELEMENT_FLAG_IS_SET (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
return !timeline_trim_object (element->timeline, element,
GES_TIMELINE_ELEMENT_LAYER_PRIORITY (element), NULL, GES_EDGE_END,
element->start + duration);
} }
container->children_control_mode = GES_CHILDREN_UPDATE; return
GES_TIMELINE_ELEMENT_CLASS (ges_source_clip_parent_class)->set_duration
return FALSE; (element, duration);
} }
static void static void
@ -125,6 +123,7 @@ ges_source_clip_class_init (GESSourceClipClass * klass)
object_class->finalize = ges_source_clip_finalize; object_class->finalize = ges_source_clip_finalize;
element_class->set_start = _set_start; element_class->set_start = _set_start;
element_class->set_duration = _set_duration;
} }
static void static void

3
ges/ges-timeline-element.c
View file

@ -694,6 +694,9 @@ ges_timeline_element_set_start (GESTimelineElement * self, GstClockTime start)
g_return_val_if_fail (GES_IS_TIMELINE_ELEMENT (self), FALSE); g_return_val_if_fail (GES_IS_TIMELINE_ELEMENT (self), FALSE);
if (self->start == start)
return TRUE;
klass = GES_TIMELINE_ELEMENT_GET_CLASS (self); klass = GES_TIMELINE_ELEMENT_GET_CLASS (self);
GST_DEBUG_OBJECT (self, "current start: %" GST_TIME_FORMAT GST_DEBUG_OBJECT (self, "current start: %" GST_TIME_FORMAT

1256
ges/ges-timeline-tree.c Normal file
View file

File diff suppressed because it is too large Load diff

79
ges/ges-timeline-tree.h Normal file
View file

@ -0,0 +1,79 @@
#ifndef __GES_TIMELINE_TREE__
#define __GES_TIMELINE_TREE__
#include <ges/ges.h>
#include "ges-auto-transition.h"
void timeline_tree_track_element (GNode *root,
GESTimelineElement *element);
void timeline_tree_stop_tracking_element (GNode *root,
GESTimelineElement *element);
gboolean timeline_tree_can_move_element (GNode *root,
GESTimelineElement *element,
guint32 priority,
GstClockTime start,
GstClockTime duration,
GList *moving_track_elements);
gboolean timeline_tree_ripple (GNode *root,
gint64 layer_priority_offset,
GstClockTimeDiff offset,
GESTimelineElement *rippled_element,
GESEdge moving_edge,
GstClockTime snapping_distance);
void ges_timeline_emit_snapping (GESTimeline * timeline,
GESTimelineElement * elem1,
GESTimelineElement * elem2,
GstClockTime snap_time);
gboolean timeline_tree_trim (GNode *root,
GESTimelineElement *element,
gint64 layer_priority_offset,
GstClockTimeDiff offset,
GESEdge edge,
GstClockTime snapping_distance);
gboolean timeline_tree_move (GNode *root,
GESTimelineElement *element,
gint64 layer_priority_offset,
GstClockTimeDiff offset,
GESEdge edge,
GstClockTime snapping_distance);
gboolean timeline_tree_roll (GNode * root,
GESTimelineElement * element,
GstClockTimeDiff offset,
GESEdge edge,
GstClockTime snapping_distance);
typedef GESAutoTransition *
(*GESTreeGetAutoTransitionFunc) (GESTimeline * timeline,
GESTrackElement * previous,
GESTrackElement * next,
GstClockTime transition_duration);
void timeline_tree_create_transitions (GNode *root,
GESTreeGetAutoTransitionFunc get_auto_transition);
GstClockTime timeline_tree_get_duration (GNode *root);
void timeline_tree_debug (GNode * root);
GESAutoTransition *
ges_timeline_create_transition (GESTimeline * timeline, GESTrackElement * previous,
GESTrackElement * next, GESClip * transition,
GESLayer * layer, guint64 start, guint64 duration);
GESAutoTransition *
ges_timeline_find_auto_transition (GESTimeline * timeline, GESTrackElement * prev,
GESTrackElement * next, GstClockTime transition_duration);
void
timeline_update_duration (GESTimeline * timeline);
void timeline_tree_init_debug (void);
#endif // __GES_TIMELINE_TREE__

1706
ges/ges-timeline.c
View file

File diff suppressed because it is too large Load diff

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

@ -1364,16 +1364,21 @@ ges_track_element_edit (GESTrackElement * object,
switch (mode) { switch (mode) {
case GES_EDIT_MODE_NORMAL: case GES_EDIT_MODE_NORMAL:
return timeline_move_object (timeline, object, layers, edge, position); return timeline_move_object (timeline, GES_TIMELINE_ELEMENT (object), -1,
layers, edge, position);
break; break;
case GES_EDIT_MODE_TRIM: case GES_EDIT_MODE_TRIM:
return timeline_trim_object (timeline, object, layers, edge, position); return timeline_trim_object (timeline, GES_TIMELINE_ELEMENT (object), -1,
layers, edge, position);
break; break;
case GES_EDIT_MODE_RIPPLE: case GES_EDIT_MODE_RIPPLE:
return timeline_ripple_object (timeline, object, layers, edge, position); return timeline_ripple_object (timeline, GES_TIMELINE_ELEMENT (object),
GES_TIMELINE_ELEMENT_PRIORITY (object) / LAYER_HEIGHT,
layers, edge, position);
break; break;
case GES_EDIT_MODE_ROLL: case GES_EDIT_MODE_ROLL:
return timeline_roll_object (timeline, object, layers, edge, position); return timeline_roll_object (timeline, GES_TIMELINE_ELEMENT (object),
layers, edge, position);
break; break;
case GES_EDIT_MODE_SLIDE: case GES_EDIT_MODE_SLIDE:
return timeline_slide_object (timeline, object, layers, edge, position); return timeline_slide_object (timeline, object, layers, edge, position);

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

@ -276,6 +276,24 @@ extractable_set_asset (GESExtractable * self, GESAsset * asset)
g_return_val_if_fail (GES_IS_URI_CLIP_ASSET (asset), FALSE); g_return_val_if_fail (GES_IS_URI_CLIP_ASSET (asset), FALSE);
uri_clip_asset = GES_URI_CLIP_ASSET (asset); uri_clip_asset = GES_URI_CLIP_ASSET (asset);
if (GST_CLOCK_TIME_IS_VALID (GES_TIMELINE_ELEMENT_DURATION (self)) &&
ges_uri_clip_asset_get_duration (uri_clip_asset) <
GES_TIMELINE_ELEMENT_INPOINT (self) +
GES_TIMELINE_ELEMENT_DURATION (self)) {
GST_INFO_OBJECT (self,
"Can not set asset to %p as its duration is %" GST_TIME_FORMAT
" < to inpoint %" GST_TIME_FORMAT " + %" GST_TIME_FORMAT " = %"
GST_TIME_FORMAT, asset,
GST_TIME_ARGS (ges_uri_clip_asset_get_duration (uri_clip_asset)),
GST_TIME_ARGS (GES_TIMELINE_ELEMENT_INPOINT (self)),
GST_TIME_ARGS (GES_TIMELINE_ELEMENT_DURATION (self)),
GST_TIME_ARGS (GES_TIMELINE_ELEMENT_INPOINT (self) +
GES_TIMELINE_ELEMENT_DURATION (self)));
return FALSE;
}
if (GST_CLOCK_TIME_IS_VALID (GES_TIMELINE_ELEMENT_DURATION (clip)) == FALSE) if (GST_CLOCK_TIME_IS_VALID (GES_TIMELINE_ELEMENT_DURATION (clip)) == FALSE)
_set_duration0 (GES_TIMELINE_ELEMENT (uriclip), _set_duration0 (GES_TIMELINE_ELEMENT (uriclip),
ges_uri_clip_asset_get_duration (uri_clip_asset)); ges_uri_clip_asset_get_duration (uri_clip_asset));

1
ges/meson.build
View file

@ -51,6 +51,7 @@ ges_sources = [
'ges-command-line-formatter.c', 'ges-command-line-formatter.c',
'ges-auto-transition.c', 'ges-auto-transition.c',
'ges-timeline-element.c', 'ges-timeline-element.c',
'ges-timeline-tree.c',
'ges-container.c', 'ges-container.c',
'ges-effect-asset.c', 'ges-effect-asset.c',
'ges-smart-adder.c', 'ges-smart-adder.c',

3
tests/check/ges/asset.c
View file

@ -227,6 +227,9 @@ GST_START_TEST (test_uri_clip_change_asset)
asset1 = GES_ASSET (ges_uri_clip_asset_request_sync (uri1, NULL)); asset1 = GES_ASSET (ges_uri_clip_asset_request_sync (uri1, NULL));
fail_unless_equals_int (g_list_length (GES_CONTAINER_CHILDREN (extractable)), fail_unless_equals_int (g_list_length (GES_CONTAINER_CHILDREN (extractable)),
2); 2);
fail_if (ges_extractable_set_asset (extractable, asset1));
ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (extractable),
ges_uri_clip_asset_get_duration (GES_URI_CLIP_ASSET (asset1)));
fail_unless (ges_extractable_set_asset (extractable, asset1)); fail_unless (ges_extractable_set_asset (extractable, asset1));
fail_unless_equals_int (g_list_length (GES_CONTAINER_CHILDREN (extractable)), fail_unless_equals_int (g_list_length (GES_CONTAINER_CHILDREN (extractable)),
1); 1);

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

@ -94,13 +94,13 @@ GST_START_TEST (test_ges_scenario)
/* There are 3 references: /* There are 3 references:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
/* There are 3 references: /* There are 3 references:
* 1 by the clip * 1 by the clip
* 2 by the timeline * 3 by the timeline
* 1 by the track */ * 1 by the track */
ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
GST_DEBUG ("Remove the Clip from the layer"); GST_DEBUG ("Remove the Clip from the layer");
@ -225,13 +225,13 @@ GST_START_TEST (test_ges_timeline_add_layer)
/* There are 3 references: /* There are 3 references:
* 1 by the clip * 1 by the clip
* 1 by the trackelement * 1 by the trackelement
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
/* There are 3 references: /* There are 3 references:
* 1 by the clip * 1 by the clip
* 1 by the timeline * 1 by the timeline
* 2 by the trackelement */ * 1 by the trackelement */
ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
trackelements = GES_CONTAINER_CHILDREN (s2); trackelements = GES_CONTAINER_CHILDREN (s2);
trackelement = GES_TRACK_ELEMENT (trackelements->data); trackelement = GES_TRACK_ELEMENT (trackelements->data);
@ -240,8 +240,8 @@ GST_START_TEST (test_ges_timeline_add_layer)
/* There are 3 references: /* There are 3 references:
* 1 by the clip * 1 by the clip
* 1 by the timeline * 1 by the timeline
* 2 by the trackelement */ * 1 by the trackelement */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (trackelement), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (trackelement), "trackelement", 3);
trackelements = GES_CONTAINER_CHILDREN (s3); trackelements = GES_CONTAINER_CHILDREN (s3);
trackelement = GES_TRACK_ELEMENT (trackelements->data); trackelement = GES_TRACK_ELEMENT (trackelements->data);
@ -251,7 +251,7 @@ GST_START_TEST (test_ges_timeline_add_layer)
* 1 by the clip * 1 by the clip
* 1 by the timeline * 1 by the timeline
* 2 by the trackelement */ * 2 by the trackelement */
ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
/* theoretically this is all we need to do to ensure cleanup */ /* theoretically this is all we need to do to ensure cleanup */
gst_object_unref (timeline); gst_object_unref (timeline);
@ -334,8 +334,8 @@ GST_START_TEST (test_ges_timeline_add_layer_first)
/* Each object has 3 references: /* Each object has 3 references:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
} }
trackelements = GES_CONTAINER_CHILDREN (s2); trackelements = GES_CONTAINER_CHILDREN (s2);
@ -344,8 +344,8 @@ GST_START_TEST (test_ges_timeline_add_layer_first)
/* Each object has 3 references: /* Each object has 3 references:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
} }
trackelements = GES_CONTAINER_CHILDREN (s3); trackelements = GES_CONTAINER_CHILDREN (s3);
@ -354,8 +354,8 @@ GST_START_TEST (test_ges_timeline_add_layer_first)
/* Each object has 3 references: /* Each object has 3 references:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
} }
/* theoretically this is all we need to do to ensure cleanup */ /* theoretically this is all we need to do to ensure cleanup */
@ -444,14 +444,14 @@ GST_START_TEST (test_ges_timeline_remove_track)
/* There are 3 references held: /* There are 3 references held:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
} }
/* There are 3 references held: /* There are 3 references held:
* 1 by the container * 1 by the container
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 4); ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 3);
trackelements = GES_CONTAINER_CHILDREN (s2); trackelements = GES_CONTAINER_CHILDREN (s2);
fail_unless (trackelements != NULL); fail_unless (trackelements != NULL);
@ -460,14 +460,14 @@ GST_START_TEST (test_ges_timeline_remove_track)
/* There are 3 references held: /* There are 3 references held:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
} }
/* There are 3 references held: /* There are 3 references held:
* 1 by the container * 1 by the container
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (t2, "t2", 4); ASSERT_OBJECT_REFCOUNT (t2, "t2", 3);
trackelements = GES_CONTAINER_CHILDREN (s3); trackelements = GES_CONTAINER_CHILDREN (s3);
fail_unless (trackelements != NULL); fail_unless (trackelements != NULL);
@ -476,21 +476,21 @@ GST_START_TEST (test_ges_timeline_remove_track)
/* There are 3 references held: /* There are 3 references held:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
} }
/* There are 3 references held: /* There are 3 references held:
* 1 by the container * 1 by the container
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (t3, "t3", 4); ASSERT_OBJECT_REFCOUNT (t3, "t3", 3);
/* remove the track and check that the track elements have been released */ /* remove the track and check that the track elements have been released */
fail_unless (ges_timeline_remove_track (timeline, track)); fail_unless (ges_timeline_remove_track (timeline, track));
ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 2); ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 1);
ASSERT_OBJECT_REFCOUNT (t2, "trackelement", 2); ASSERT_OBJECT_REFCOUNT (t2, "trackelement", 1);
ASSERT_OBJECT_REFCOUNT (t3, "trackelement", 2); ASSERT_OBJECT_REFCOUNT (t3, "trackelement", 1);
ASSERT_OBJECT_REFCOUNT (layer, "1 for the timeline", 1); ASSERT_OBJECT_REFCOUNT (layer, "1 for the timeline", 1);
ASSERT_OBJECT_REFCOUNT (timeline, "1 for the us", 1); ASSERT_OBJECT_REFCOUNT (timeline, "1 for the us", 1);
tmp = ges_layer_get_clips (layer); tmp = ges_layer_get_clips (layer);
@ -614,17 +614,17 @@ GST_START_TEST (test_ges_timeline_multiple_tracks)
/* There are 3 references held: /* There are 3 references held:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
fail_unless (ges_track_element_get_track (tmp->data) == track1); fail_unless (ges_track_element_get_track (tmp->data) == track1);
} }
gst_object_ref (t1); gst_object_ref (t1);
/* There are 3 references held: /* There are 3 references held:
* 1 by the container * 1 by the container
* 1 by the track * 1 by the track
* 2 by the timeline * 1 by the timeline
* 1 added by ourselves above (gst_object_ref (t1)) */ * 1 added by ourselves above (gst_object_ref (t1)) */
ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 5); ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 4);
trackelements = GES_CONTAINER_CHILDREN (s2); trackelements = GES_CONTAINER_CHILDREN (s2);
fail_unless (trackelements != NULL); fail_unless (trackelements != NULL);
@ -633,17 +633,17 @@ GST_START_TEST (test_ges_timeline_multiple_tracks)
/* There are 3 references held: /* There are 3 references held:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
fail_unless (ges_track_element_get_track (tmp->data) == track2); fail_unless (ges_track_element_get_track (tmp->data) == track2);
} }
gst_object_ref (t2); gst_object_ref (t2);
/* There are 3 references held: /* There are 3 references held:
* 1 by the container * 1 by the container
* 1 by the track * 1 by the track
* 2 by the timeline * 1 by the timeline
* 1 added by ourselves above (gst_object_ref (t2)) */ * 1 added by ourselves above (gst_object_ref (t2)) */
ASSERT_OBJECT_REFCOUNT (t2, "t2", 5); ASSERT_OBJECT_REFCOUNT (t2, "t2", 4);
trackelements = GES_CONTAINER_CHILDREN (s3); trackelements = GES_CONTAINER_CHILDREN (s3);
fail_unless (trackelements != NULL); fail_unless (trackelements != NULL);
@ -652,17 +652,17 @@ GST_START_TEST (test_ges_timeline_multiple_tracks)
/* There are 3 references held: /* There are 3 references held:
* 1 by the clip * 1 by the clip
* 1 by the track * 1 by the track
* 2 by the timeline */ * 1 by the timeline */
ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4); ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 3);
fail_unless (ges_track_element_get_track (tmp->data) == track1); fail_unless (ges_track_element_get_track (tmp->data) == track1);
} }
gst_object_ref (t3); gst_object_ref (t3);
/* There are 3 references held: /* There are 3 references held:
* 1 by the container * 1 by the container
* 1 by the track * 1 by the track
* 2 by the timeline * 1 by the timeline
* 1 added by ourselves above (gst_object_ref (t3)) */ * 1 added by ourselves above (gst_object_ref (t3)) */
ASSERT_OBJECT_REFCOUNT (t3, "t3", 5); ASSERT_OBJECT_REFCOUNT (t3, "t3", 4);
gst_object_unref (t1); gst_object_unref (t1);
gst_object_unref (t2); gst_object_unref (t2);

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

@ -365,7 +365,7 @@ GST_START_TEST (test_split_object)
/* 1 ref for the Clip, 1 ref for the Track and 2 ref for the timeline /* 1 ref for the Clip, 1 ref for the Track and 2 ref for the timeline
* (1 for the "all_element" hashtable, another for the sequence of TrackElement*/ * (1 for the "all_element" hashtable, another for the sequence of TrackElement*/
ASSERT_OBJECT_REFCOUNT (splittrackelement, ASSERT_OBJECT_REFCOUNT (splittrackelement,
"1 ref for the Clip, 1 ref for the Track and 2 ref for the timeline", 4); "1 ref for the Clip, 1 ref for the Track and 1 ref for the timeline", 3);
check_destroyed (G_OBJECT (timeline), G_OBJECT (splitclip), clip, check_destroyed (G_OBJECT (timeline), G_OBJECT (splitclip), clip,
splittrackelement, NULL); splittrackelement, NULL);
@ -429,7 +429,7 @@ GST_START_TEST (test_clip_group_ungroup)
tmp = ges_track_get_elements (audio_track); tmp = ges_track_get_elements (audio_track);
assert_equals_int (g_list_length (tmp), 1); assert_equals_int (g_list_length (tmp), 1);
ASSERT_OBJECT_REFCOUNT (tmp->data, "1 for the track + 1 for the container " ASSERT_OBJECT_REFCOUNT (tmp->data, "1 for the track + 1 for the container "
"+ 2 for the timeline + 1 in tmp list", 5); "+ 1 for the timeline + 1 in tmp list", 4);
assert_equals_int (ges_track_element_get_track_type (tmp->data), assert_equals_int (ges_track_element_get_track_type (tmp->data),
GES_TRACK_TYPE_AUDIO); GES_TRACK_TYPE_AUDIO);
assert_equals_int (ges_clip_get_supported_formats (GES_CLIP assert_equals_int (ges_clip_get_supported_formats (GES_CLIP
@ -438,7 +438,7 @@ GST_START_TEST (test_clip_group_ungroup)
tmp = ges_track_get_elements (video_track); tmp = ges_track_get_elements (video_track);
assert_equals_int (g_list_length (tmp), 1); assert_equals_int (g_list_length (tmp), 1);
ASSERT_OBJECT_REFCOUNT (tmp->data, "1 for the track + 1 for the container " ASSERT_OBJECT_REFCOUNT (tmp->data, "1 for the track + 1 for the container "
"+ 2 for the timeline + 1 in tmp list", 5); "+ 1 for the timeline + 1 in tmp list", 4);
assert_equals_int (ges_track_element_get_track_type (tmp->data), assert_equals_int (ges_track_element_get_track_type (tmp->data),
GES_TRACK_TYPE_VIDEO); GES_TRACK_TYPE_VIDEO);
assert_equals_int (ges_clip_get_supported_formats (GES_CLIP assert_equals_int (ges_clip_get_supported_formats (GES_CLIP
@ -489,7 +489,7 @@ GST_START_TEST (test_clip_group_ungroup)
tmp = ges_track_get_elements (video_track); tmp = ges_track_get_elements (video_track);
assert_equals_int (g_list_length (tmp), 1); assert_equals_int (g_list_length (tmp), 1);
ASSERT_OBJECT_REFCOUNT (tmp->data, "1 for the track + 1 for the container " ASSERT_OBJECT_REFCOUNT (tmp->data, "1 for the track + 1 for the container "
"+ 2 for the timeline + 1 in tmp list", 5); "+ 1 for the timeline + 1 in tmp list", 4);
assert_equals_int (ges_track_element_get_track_type (tmp->data), assert_equals_int (ges_track_element_get_track_type (tmp->data),
GES_TRACK_TYPE_VIDEO); GES_TRACK_TYPE_VIDEO);
fail_unless (GES_CONTAINER (ges_timeline_element_get_parent (tmp->data)) == fail_unless (GES_CONTAINER (ges_timeline_element_get_parent (tmp->data)) ==

164
tests/check/ges/group.c
View file

@ -165,147 +165,69 @@ GST_START_TEST (test_move_group)
CHECK_OBJECT_PROPS (clip2, 60, 0, 50); CHECK_OBJECT_PROPS (clip2, 60, 0, 50);
CHECK_OBJECT_PROPS (group, 10, 0, 100); CHECK_OBJECT_PROPS (group, 10, 0, 100);
ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2); ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2);
fail_if (ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 20));
/* CHECK_OBJECT_PROPS (clip, 10, 0, 5);
* 0 20---Group1---------------110
* | |
* layer: | |
* | |
* |--------------------------|
* 5--------- 0------------|
* layer1: | clip1 | | clip2 |
* 20--------30 60----------|
* |--------------------------|
*/
ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 20);
CHECK_OBJECT_PROPS (clip, 15, 5, 0);
CHECK_OBJECT_PROPS (clip1, 20, 5, 10); CHECK_OBJECT_PROPS (clip1, 20, 5, 10);
CHECK_OBJECT_PROPS (clip2, 60, 0, 50); CHECK_OBJECT_PROPS (clip2, 60, 0, 50);
CHECK_OBJECT_PROPS (group, 20, 0, 90); CHECK_OBJECT_PROPS (group, 10, 0, 100);
/*
* 0 25---Group1---------------110
* | |
* layer: | |
* | |
* |--------------------------|
* 10------ 0------------|
* layer1: | clip1 | | clip2 |
* 25------30 60----------|
* |--------------------------|
*/
ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 25);
CHECK_OBJECT_PROPS (clip, 15, 5, 0);
CHECK_OBJECT_PROPS (clip1, 25, 10, 5);
CHECK_OBJECT_PROPS (clip2, 60, 0, 50);
CHECK_OBJECT_PROPS (group, 25, 0, 85);
ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2); ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2);
/* fail_if (ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 25));
* 0 10------------Group1------------------110 CHECK_OBJECT_PROPS (clip, 10, 0, 5);
* |------ | CHECK_OBJECT_PROPS (clip1, 20, 5, 10);
* layer: |clip | | CHECK_OBJECT_PROPS (clip2, 60, 0, 50);
* |-----15 | CHECK_OBJECT_PROPS (group, 10, 0, 100);
* |-------------------------------------| ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2);
* | 10------ 0------------|
* layer1: | | clip1 | | clip2 | /* Same thing in the end... */
* | 25------30 60----------|
* | |--------------------------|
* |-------------------------------------|
*/
ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 10); ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 10);
CHECK_OBJECT_PROPS (clip, 10, 0, 5); CHECK_OBJECT_PROPS (clip, 10, 0, 5);
CHECK_OBJECT_PROPS (clip1, 25, 10, 5); CHECK_OBJECT_PROPS (clip1, 20, 5, 10);
CHECK_OBJECT_PROPS (clip2, 60, 0, 50); CHECK_OBJECT_PROPS (clip2, 60, 0, 50);
CHECK_OBJECT_PROPS (group, 10, 0, 100); CHECK_OBJECT_PROPS (group, 10, 0, 100);
ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2); ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2);
/* /*
* 0 25---Group1---------------110 * 0 12------------Group1---------------110
* | | * 2------ |
* layer: 15 | | * layer: |clip | |
* |clip | | * |-----15 |
* - |--------------------------| * |----------------------------------|
* 10------ 0------------| * | 7--------- 2----------|
* layer1: | clip1 | | clip2 | * layer1: | | clip1 | | clip2 |
* 25------30 60----------| * | 22--------30 62----------|
* |--------------------------| * |----------------------------------|
*/ */
ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 25); ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 12);
CHECK_OBJECT_PROPS (clip, 15, 5, 0); CHECK_OBJECT_PROPS (clip, 12, 2, 3);
CHECK_OBJECT_PROPS (clip1, 25, 10, 5); CHECK_OBJECT_PROPS (clip1, 22, 7, 8);
CHECK_OBJECT_PROPS (clip2, 60, 0, 50); CHECK_OBJECT_PROPS (clip2, 62, 2, 48);
CHECK_OBJECT_PROPS (group, 25, 0, 85); CHECK_OBJECT_PROPS (group, 12, 0, 98);
ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2); ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2);
/* /* Setting the duration would lead to overlaps */
* 0 25---Group1--30
* | |
* layer: 15 | |
* |clip | |
* - |------------
* 15-----------| 60
* layer1: | clip1 | |clip2
* 25------------| -
* |------------|
*/
ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (group), 10); ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (group), 10);
CHECK_OBJECT_PROPS (clip, 15, 5, 0); CHECK_OBJECT_PROPS (clip, 12, 2, 3);
CHECK_OBJECT_PROPS (clip1, 25, 10, 5); CHECK_OBJECT_PROPS (clip1, 22, 7, 8);
CHECK_OBJECT_PROPS (clip2, 60, 0, 0); CHECK_OBJECT_PROPS (clip2, 62, 2, 48);
CHECK_OBJECT_PROPS (group, 25, 0, 5); CHECK_OBJECT_PROPS (group, 12, 0, 98);
/*
* 0 25---Group1---------------125
* | |
* layer: 15 | |
* |clip | |
* - |--------------------------|
* 10-------------------------|
* layer1: | clip1 | clip2 |
* 25--------------60----------|
* |--------------------------|
*/
ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (group), 100); ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (group), 100);
CHECK_OBJECT_PROPS (clip, 15, 5, 0); CHECK_OBJECT_PROPS (clip, 12, 2, 3);
CHECK_OBJECT_PROPS (clip1, 25, 10, 100); CHECK_OBJECT_PROPS (clip1, 22, 7, 8);
CHECK_OBJECT_PROPS (clip2, 60, 0, 65); CHECK_OBJECT_PROPS (clip2, 62, 2, 50);
CHECK_OBJECT_PROPS (group, 25, 0, 100); CHECK_OBJECT_PROPS (group, 12, 0, 100);
ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2);
/*
* 0 20---Group1---------------120
* | |
* layer: 15 | |
* |clip| |
* - |--------------------------|
* 10-------------------------|
* layer1: | clip1 | clip2 |
* 20-------------55----------|
* |--------------------------|
*/
ges_timeline_element_set_start (GES_TIMELINE_ELEMENT (group), 20); ges_timeline_element_set_start (GES_TIMELINE_ELEMENT (group), 20);
CHECK_OBJECT_PROPS (clip, 15, 5, 0); CHECK_OBJECT_PROPS (clip, 20, 2, 3);
CHECK_OBJECT_PROPS (clip1, 20, 10, 100); CHECK_OBJECT_PROPS (clip1, 30, 7, 8);
CHECK_OBJECT_PROPS (clip2, 55, 0, 65); CHECK_OBJECT_PROPS (clip2, 70, 2, 50);
CHECK_OBJECT_PROPS (group, 20, 0, 100); CHECK_OBJECT_PROPS (group, 20, 0, 100);
/* fail_if (ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 10));
* 0 10---Group1---------------120 CHECK_OBJECT_PROPS (clip, 20, 2, 3);
* |-----15 | CHECK_OBJECT_PROPS (clip1, 30, 7, 8);
* layer: | clip| | CHECK_OBJECT_PROPS (clip2, 70, 2, 50);
* |------ | CHECK_OBJECT_PROPS (group, 20, 0, 100);
* |--------------------------|
* 5--------------------------|
* layer1: | clip1 | clip2 |
* 10-------------55----------|
* |--------------------------|
*/
ges_timeline_element_trim (GES_TIMELINE_ELEMENT (group), 10);
CHECK_OBJECT_PROPS (clip, 10, 0, 5);
CHECK_OBJECT_PROPS (clip1, 10, 0, 110);
CHECK_OBJECT_PROPS (clip2, 55, 0, 65);
CHECK_OBJECT_PROPS (group, 10, 0, 110);
ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2); ASSERT_OBJECT_REFCOUNT (group, "2 ref for the timeline", 2);
check_destroyed (G_OBJECT (timeline), G_OBJECT (group), NULL); check_destroyed (G_OBJECT (timeline), G_OBJECT (group), NULL);

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

@ -308,7 +308,7 @@ GST_START_TEST (test_single_layer_automatic_transition)
{ {
GESAsset *asset; GESAsset *asset;
GESTimeline *timeline; GESTimeline *timeline;
GList *objects, *current; GList *objects;
GESClip *transition; GESClip *transition;
GESLayer *layer; GESLayer *layer;
GESTimelineElement *src, *src1, *src2; GESTimelineElement *src, *src1, *src2;
@ -379,24 +379,19 @@ GST_START_TEST (test_single_layer_automatic_transition)
ges_timeline_element_set_start (src, 250); ges_timeline_element_set_start (src, 250);
/* /*
* 500_____transition____1250 * 600_____transition______1500
* 250___________src_________1250 * 600___________src_________1600
* 500___________src1_________1500 * 500___________src1_________1500
*/ */
GST_DEBUG ("Checking src timing values"); GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 250); CHECK_OBJECT_PROPS (src, 250, 0, 1000);
assert_equals_uint64 (_DURATION (src), 1250 - 250); CHECK_OBJECT_PROPS (src1, 500, 0, 1000);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1500 - 500);
objects = ges_layer_get_clips (layer); objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 4); assert_equals_int (g_list_length (objects), 4);
assert_is_type (objects->data, GES_TYPE_TEST_CLIP);
transition = objects->next->data; transition = objects->next->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP); assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 500); CHECK_OBJECT_PROPS (transition, 500, 0, 750);
assert_equals_uint64 (_DURATION (transition), 750);
transition = objects->next->next->data; transition = objects->next->next->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP); assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
@ -404,295 +399,65 @@ GST_START_TEST (test_single_layer_automatic_transition)
assert_equals_uint64 (_DURATION (transition), 750); assert_equals_uint64 (_DURATION (transition), 750);
g_list_free_full (objects, gst_object_unref); g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Moving second source to 250, the transitions should be removed"); fail_if (ges_timeline_element_set_start (src1, 250));
ges_timeline_element_set_start (src1, 250);
/* The transition should be removed fail_if (ges_container_edit (GES_CONTAINER (src), NULL, -1,
* 250___________src_________1250 GES_EDIT_MODE_TRIM, GES_EDGE_START, 500));
* 250___________src1________1250 CHECK_OBJECT_PROPS (src, 250, 0, 1000);
CHECK_OBJECT_PROPS (src1, 500, 0, 1000);
fail_if (ges_timeline_element_trim (src, 500));
CHECK_OBJECT_PROPS (src, 250, 0, 1000);
CHECK_OBJECT_PROPS (src1, 500, 0, 1000);
fail_if (ges_timeline_element_trim (src, 750));
CHECK_OBJECT_PROPS (src, 250, 0, 1000);
CHECK_OBJECT_PROPS (src1, 500, 0, 1000);
fail_if (ges_timeline_element_set_start (src, 500));
CHECK_OBJECT_PROPS (src, 250, 0, 1000);
CHECK_OBJECT_PROPS (src1, 500, 0, 1000);
/*
* 600_____transition______1500
* 600___________src_________1600
* 500___________src1_________1500
*/ */
GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 250);
assert_equals_uint64 (_DURATION (src), 1250 - 250);
assert_equals_uint64 (_START (src1), 250);
assert_equals_uint64 (_DURATION (src1), 1250 - 250);
objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 2);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Trimming second source to 500 no transition should be created "
"as they have the same end");
ges_container_edit (GES_CONTAINER (src1), NULL, -1,
GES_EDIT_MODE_TRIM, GES_EDGE_START, 500);
/* 250___________src_________1250
* 500______src1_______1250
*/
GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 250);
assert_equals_uint64 (_DURATION (src), 1250 - 250);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 2);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Trimming second source to 500, no transition should be created");
ges_timeline_element_trim (src, 500);
/* 500___________src_________1250
* 500___________src1________1250
*/
GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 500);
assert_equals_uint64 (_DURATION (src), 1250 - 500);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
GST_DEBUG ("Trimming first source to 750, no transition should be created");
ges_timeline_element_trim (src, 750);
/* 750_______src_______1250
* 500___________src1________1250
*/
GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 750);
assert_equals_uint64 (_DURATION (src), 1250 - 750);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 2);
g_list_free_full (objects, gst_object_unref);
objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 2);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Moving first source to 500, no transition should be created");
ges_timeline_element_set_start (src, 500);
/* 500________src______1000
* 500___________src1________1250
*/
GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 500);
assert_equals_uint64 (_DURATION (src), 1000 - 500);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 2);
g_list_free_full (objects, gst_object_unref);
objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 2);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Moving first source to 600, no transition should be created");
ges_timeline_element_set_start (src, 600); ges_timeline_element_set_start (src, 600);
/* 600____src___1100 CHECK_OBJECT_PROPS (src, 600, 0, 1000);
* 500___________src1________1250 CHECK_OBJECT_PROPS (src1, 500, 0, 1000);
*/
GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 600);
assert_equals_uint64 (_DURATION (src), 1100 - 600);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
objects = ges_layer_get_clips (layer); objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 2); assert_equals_int (g_list_length (objects), 4);
g_list_free_full (objects, gst_object_unref); transition = objects->next->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
objects = ges_layer_get_clips (layer); CHECK_OBJECT_PROPS (transition, 600, 0, 900);
assert_equals_int (g_list_length (objects), 2);
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 clip from 1250 -- 1000 to first layer"); GST_DEBUG ("Adding clip from 1250 -- 1000 to first layer");
src2 = fail_if (ges_layer_add_asset (layer, asset, 1250, 0,
GES_TIMELINE_ELEMENT (ges_layer_add_asset (layer, asset, 1250, 0,
1000, GES_TRACK_TYPE_UNKNOWN)); 1000, GES_TRACK_TYPE_UNKNOWN));
/*
* 1500___________src2________2000
* 1500_trans_1600
* 600______________src________________1600
* 600_____transition______1500
* 500___________src1_________1500
*/
src2 = GES_TIMELINE_ELEMENT (ges_layer_add_asset (layer, asset, 1500, 0,
500, GES_TRACK_TYPE_UNKNOWN));
assert_is_type (src2, GES_TYPE_TEST_CLIP); assert_is_type (src2, GES_TYPE_TEST_CLIP);
/* 600____src___1100 CHECK_OBJECT_PROPS (src, 600, 0, 1000);
* 500___________src1________1250 CHECK_OBJECT_PROPS (src1, 500, 0, 1000);
* 1250___________src2________2250 CHECK_OBJECT_PROPS (src2, 1500, 0, 500);
*/
assert_equals_uint64 (_START (src), 600);
assert_equals_uint64 (_DURATION (src), 1100 - 600);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
assert_equals_uint64 (_START (src2), 1250);
assert_equals_uint64 (_DURATION (src2), 1000);
objects = ges_layer_get_clips (layer); objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 3); transition = objects->next->next->data;
g_list_free_full (objects, gst_object_unref);
GST_DEBUG
("Changig first source duration to 800 2 transitions should be created");
ges_timeline_element_set_duration (src, 800);
ges_timeline_commit (timeline);
/* 600__________________src_____________1400
* 500___________src1________1250
* 1250___________src2________2250
* 600_____trans1_______1250
* 1250___trans2___1400
*/
GST_DEBUG ("Checking src timing values");
assert_equals_uint64 (_START (src), 600);
assert_equals_uint64 (_DURATION (src), 1400 - 600);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
current = objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 7); assert_equals_int (g_list_length (objects), 7);
assert_is_type (objects->data, GES_TYPE_TEST_CLIP);
fail_unless (objects->data == src1);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP); assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 600); CHECK_OBJECT_PROPS (transition, 600, 0, 900);
assert_equals_uint64 (_DURATION (transition), 1250 - 600); transition = objects->next->next->next->next->data;
ASSERT_OBJECT_REFCOUNT (transition, "layer + timeline + ourself", 3);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP); assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 600); CHECK_OBJECT_PROPS (transition, 1500, 0, 100);
assert_equals_uint64 (_DURATION (transition), 1250 - 600);
ASSERT_OBJECT_REFCOUNT (transition, "layer + timeline + ourself", 3);
current = current->next;
fail_unless (current->data == src);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 1250);
assert_equals_uint64 (_DURATION (transition), 1400 - 1250);
ASSERT_OBJECT_REFCOUNT (transition, "layer + timeline + ourself", 3);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 1250);
assert_equals_uint64 (_DURATION (transition), 1400 - 1250);
ASSERT_OBJECT_REFCOUNT (transition, "layer + timeline + ourself", 3);
current = current->next;
fail_unless (current->data == src2);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Back to previous state");
/* Make sure to keep 1 ref so we can check_destroyed afterward */
gst_object_ref (transition);
ges_timeline_element_set_duration (src, 1100 - 600);
/* 600____src___1100
* 500___________src1________1250
* 1250___________src2________2250
*/
assert_equals_uint64 (_START (src), 600);
assert_equals_uint64 (_DURATION (src), 1100 - 600);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
assert_equals_uint64 (_START (src2), 1250);
assert_equals_uint64 (_DURATION (src2), 1000);
/* We check that the transition as actually been freed */
check_destroyed (G_OBJECT (transition), NULL, NULL);
objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 3);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG
("Set third clip start to 1100, 1 new transition should be created");
ges_timeline_element_set_start (src2, 1100);
ges_timeline_commit (timeline);
/* 600____src___1100
* 500___________src1________1250
* 1100___________src2________2100
* ^__trans___^
*/
assert_equals_uint64 (_START (src), 600);
assert_equals_uint64 (_DURATION (src), 1100 - 600);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
assert_equals_uint64 (_START (src2), 1100);
assert_equals_uint64 (_DURATION (src2), 1000);
current = objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 5);
assert_is_type (objects->data, GES_TYPE_TEST_CLIP);
fail_unless (current->data == src1);
current = current->next;
fail_unless (current->data == src);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 1100);
assert_equals_uint64 (_DURATION (transition), 1250 - 1100);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 1100);
assert_equals_uint64 (_DURATION (transition), 1250 - 1100);
current = current->next;
fail_unless (current->data == src2);
g_list_free_full (objects, gst_object_unref);
GST_DEBUG ("Check that we can not create 2 transitions at the same place");
fail_if (ges_container_edit (GES_CONTAINER (src2), NULL, -1,
GES_EDIT_MODE_NORMAL, GES_EDGE_START, 1000));
/*
* 500___________src1________1250
* 1000___________src2________2000
* ^____trans____^
*/
ges_layer_remove_clip (layer, GES_CLIP (src));
fail_unless (ges_container_edit (GES_CONTAINER (src2), NULL, -1,
GES_EDIT_MODE_NORMAL, GES_EDGE_START, 1000));
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
assert_equals_uint64 (_START (src2), 1000);
assert_equals_uint64 (_DURATION (src2), 1000);
current = objects = ges_layer_get_clips (layer);
current = objects;
assert_equals_int (g_list_length (objects), 4);
assert_is_type (objects->data, GES_TYPE_TEST_CLIP);
transition = objects->next->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
fail_unless (current->data == src1);
g_list_free_full (objects, gst_object_unref);
/*
* 500___________src1________1250
* ^____trans____^
* 1100___________src2________2000
*/
ges_container_edit (GES_CONTAINER (transition),
NULL, -1, GES_EDIT_MODE_TRIM, GES_EDGE_START, 1100);
assert_equals_uint64 (_START (src1), 500);
assert_equals_uint64 (_DURATION (src1), 1250 - 500);
assert_equals_uint64 (_START (src2), 1100);
assert_equals_uint64 (_DURATION (src2), 2000 - 1100);
current = objects = ges_layer_get_clips (layer);
current = objects;
assert_equals_int (g_list_length (objects), 4);
assert_is_type (objects->data, GES_TYPE_TEST_CLIP);
fail_unless (current->data == src1);
g_list_free_full (objects, gst_object_unref); g_list_free_full (objects, gst_object_unref);
gst_object_unref (timeline); gst_object_unref (timeline);
@ -1006,7 +771,7 @@ GST_START_TEST (test_multi_layer_automatic_transition)
GST_DEBUG GST_DEBUG
("Moving src to second layer, should remove first transition on first layer"); ("Moving src to second layer, should remove first transition on first layer");
ges_clip_move_to_layer (GES_CLIP (src), layer1); fail_if (ges_clip_move_to_layer (GES_CLIP (src), layer1));
/* 500___________src1_________1500 /* 500___________src1_________1500
* 1000___________src3_________2000 Layer * 1000___________src3_________2000 Layer
@ -1027,31 +792,8 @@ GST_START_TEST (test_multi_layer_automatic_transition)
GST_DEBUG ("Checking transitions on first layer"); GST_DEBUG ("Checking transitions on first layer");
current = objects = ges_layer_get_clips (layer); current = objects = ges_layer_get_clips (layer);
assert_equals_int (g_list_length (objects), 4); assert_equals_int (g_list_length (objects), 7);
fail_unless (current->data == src1);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 1000);
assert_equals_uint64 (_DURATION (transition), 500);
current = current->next;
transition = current->data;
assert_is_type (transition, GES_TYPE_TRANSITION_CLIP);
assert_equals_uint64 (_START (transition), 1000);
assert_equals_uint64 (_DURATION (transition), 500);
current = current->next;
fail_unless (current->data == src3);
g_list_free_full (objects, gst_object_unref);
ASSERT_OBJECT_REFCOUNT (transition, "layer + timeline", 2);
GST_DEBUG ("Checking second layer");
current = objects = ges_layer_get_clips (layer1);
assert_equals_int (g_list_length (objects), 2);
assert_is_type (current->data, GES_TYPE_TEST_CLIP);
assert_is_type (current->next->data, GES_TYPE_TEST_CLIP);
g_list_free_full (objects, gst_object_unref); g_list_free_full (objects, gst_object_unref);
ASSERT_OBJECT_REFCOUNT (transition, "layer + timeline", 2); ASSERT_OBJECT_REFCOUNT (transition, "layer + timeline", 2);

23
tests/check/ges/test-utils.h
View file

@ -83,30 +83,37 @@ G_STMT_START { \
#define _DURATION(obj) GES_TIMELINE_ELEMENT_DURATION (obj) #define _DURATION(obj) GES_TIMELINE_ELEMENT_DURATION (obj)
#define _INPOINT(obj) GES_TIMELINE_ELEMENT_INPOINT (obj) #define _INPOINT(obj) GES_TIMELINE_ELEMENT_INPOINT (obj)
#define _PRIORITY(obj) GES_TIMELINE_ELEMENT_PRIORITY (obj) #define _PRIORITY(obj) GES_TIMELINE_ELEMENT_PRIORITY (obj)
#ifndef _END
#define _END(obj) (_START(obj) + _DURATION(obj))
#endif
#define CHECK_OBJECT_PROPS(obj, start, inpoint, duration) {\ #define CHECK_OBJECT_PROPS(obj, start, inpoint, duration) {\
assert_equals_uint64 (_START (obj), start);\ fail_unless (_START (obj) == start, "%s start is %" GST_TIME_FORMAT " != %" GST_TIME_FORMAT, GES_TIMELINE_ELEMENT_NAME(obj), GST_TIME_ARGS (_START(obj)), GST_TIME_ARGS (start));\
assert_equals_uint64 (_INPOINT (obj), inpoint);\ fail_unless (_INPOINT (obj) == inpoint, "%s inpoint is %" GST_TIME_FORMAT " != %" GST_TIME_FORMAT, GES_TIMELINE_ELEMENT_NAME(obj), GST_TIME_ARGS (_INPOINT(obj)), GST_TIME_ARGS (inpoint));\
assert_equals_uint64 (_DURATION (obj), duration);\ fail_unless (_DURATION (obj) == duration, "%s duration is %" GST_TIME_FORMAT " != %" GST_TIME_FORMAT, GES_TIMELINE_ELEMENT_NAME(obj), GST_TIME_ARGS (_DURATION(obj)), GST_TIME_ARGS (duration));\
} }
#define check_layer(clip, layer_prio) { \ #define check_layer(clip, layer_prio) { \
GESLayer *tmplayer = ges_clip_get_layer ((clip)); \ fail_unless (GES_TIMELINE_ELEMENT_LAYER_PRIORITY (clip) == (layer_prio), \
assert_equals_int (ges_layer_get_priority (tmplayer), (layer_prio)); \ "%s in layer %d instead of %d", GES_TIMELINE_ELEMENT_NAME (clip), \
gst_object_unref (tmplayer); \ GES_TIMELINE_ELEMENT_LAYER_PRIORITY (clip), layer_prio); \
} }
#define GES_TIMELINE_ELEMENT_FORMAT \ #define GES_TIMELINE_ELEMENT_FORMAT \
"s<%p>" \ "s<%p>" \
" [ %" GST_TIME_FORMAT \ " [ %" GST_TIME_FORMAT \
" (%" GST_TIME_FORMAT \ " (%" GST_TIME_FORMAT \
") - %" GST_TIME_FORMAT "]" ") - %" GST_TIME_FORMAT "(%" GST_TIME_FORMAT") layer: %" G_GINT32_FORMAT "] "
#define GES_TIMELINE_ELEMENT_ARGS(element) \ #define GES_TIMELINE_ELEMENT_ARGS(element) \
GES_TIMELINE_ELEMENT_NAME(element), element, \ GES_TIMELINE_ELEMENT_NAME(element), element, \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_START(element)), \ GST_TIME_ARGS(GES_TIMELINE_ELEMENT_START(element)), \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_INPOINT(element)), \ GST_TIME_ARGS(GES_TIMELINE_ELEMENT_INPOINT(element)), \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_DURATION(element)) GST_TIME_ARGS(GES_TIMELINE_ELEMENT_DURATION(element)), \
GST_TIME_ARGS(GES_TIMELINE_ELEMENT_MAX_DURATION(element)), \
GES_TIMELINE_ELEMENT_LAYER_PRIORITY(element)
#define GES_ARGS GES_TIMELINE_ELEMENT_ARGS
#define GES_FORMAT GES_TIMELINE_ELEMENT_FORMAT
void print_timeline(GESTimeline *timeline); void print_timeline(GESTimeline *timeline);

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

@ -25,19 +25,21 @@
#define DEEP_CHECK(element, start, inpoint, duration) \ #define DEEP_CHECK(element, start, inpoint, duration) \
{ \ { \
GList *track_elements, *tmp; \ GList *track_elements, *tmp; \
\ CHECK_OBJECT_PROPS (element, start, inpoint, duration) \
assert_equals_uint64 (_START (element), start); \
assert_equals_uint64 (_INPOINT (element), inpoint); \
assert_equals_uint64 (_DURATION (element), duration); \
\ \
track_elements = GES_CONTAINER_CHILDREN (element); \ track_elements = GES_CONTAINER_CHILDREN (element); \
for (tmp = track_elements; tmp; tmp = tmp->next) { \ for (tmp = track_elements; tmp; tmp = tmp->next) { \
assert_equals_uint64 (_START (tmp->data), start); \ CHECK_OBJECT_PROPS (tmp->data, start, inpoint, duration) \
assert_equals_uint64 (_INPOINT (tmp->data), inpoint); \
assert_equals_uint64 (_DURATION (tmp->data), duration); \
} \ } \
} }
#define CHECK_CLIP(element, start, inpoint, duration, layer_prio) \
{ \
DEEP_CHECK(element, start, inpoint, duration);\
check_layer (element, layer_prio); \
}\
GST_START_TEST (test_basic_timeline_edition) GST_START_TEST (test_basic_timeline_edition)
{ {
GESAsset *asset; GESAsset *asset;
@ -288,7 +290,7 @@ GST_START_TEST (test_snapping)
fail_unless (ges_track_element_get_track (trackelement) == track); fail_unless (ges_track_element_get_track (trackelement) == track);
assert_equals_uint64 (_DURATION (trackelement), 37); assert_equals_uint64 (_DURATION (trackelement), 37);
ASSERT_OBJECT_REFCOUNT (trackelement, "track + timeline + clip", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "track + timeline + clip", 3);
ASSERT_OBJECT_REFCOUNT (clip, "layer + timeline", 2); ASSERT_OBJECT_REFCOUNT (clip, "layer + timeline", 2);
fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip1))); fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip1)));
@ -299,7 +301,7 @@ GST_START_TEST (test_snapping)
assert_equals_uint64 (_DURATION (trackelement1), 15); assert_equals_uint64 (_DURATION (trackelement1), 15);
/* Same ref logic */ /* Same ref logic */
ASSERT_OBJECT_REFCOUNT (trackelement1, "First trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement1, "First trackelement", 3);
ASSERT_OBJECT_REFCOUNT (clip1, "First clip", 2); ASSERT_OBJECT_REFCOUNT (clip1, "First clip", 2);
fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip2))); fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip2)));
@ -310,7 +312,7 @@ GST_START_TEST (test_snapping)
assert_equals_uint64 (_DURATION (trackelement2), 60); assert_equals_uint64 (_DURATION (trackelement2), 60);
/* Same ref logic */ /* Same ref logic */
ASSERT_OBJECT_REFCOUNT (trackelement2, "First trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement2, "First trackelement", 3);
ASSERT_OBJECT_REFCOUNT (clip2, "First clip", 2); ASSERT_OBJECT_REFCOUNT (clip2, "First clip", 2);
/* Snaping to edge, so no move */ /* Snaping to edge, so no move */
@ -322,8 +324,7 @@ GST_START_TEST (test_snapping)
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60); CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Snaping to edge, so no move */ /* Snaping to edge, so no move */
fail_if (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_TRIM, ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, 27);
GES_EDGE_END, 27));
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5); CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60); CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
@ -338,144 +339,78 @@ GST_START_TEST (test_snapping)
*/ */
g_object_set (timeline, "snapping-distance", (guint64) 0, NULL); g_object_set (timeline, "snapping-distance", (guint64) 0, NULL);
ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (clip1), 10); ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (clip1), 10);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); DEEP_CHECK (clip, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10); DEEP_CHECK (clip1, 20, 0, 10);
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60); DEEP_CHECK (clip2, 62, 0, 60);
/** /* clip and clip1 would fully overlap ... forbiden */
* New timeline(the "layers" are just to help reading diagram, nothing else): fail_if (ges_timeline_element_roll_end (GES_TIMELINE_ELEMENT (clip1), 62));
* ------------ DEEP_CHECK (clip, 25, 0, 37);
* 0---------- DEEP_CHECK (clip1, 20, 0, 10);
* | clip | DEEP_CHECK (clip2, 62, 0, 60);
* 25---------62 fail_if (ges_timeline_element_roll_end (GES_TIMELINE_ELEMENT (clip1),
* inpoints 0----------------------- 10--------
* | clip1 || clip2 |
* time 20---------------------- 72 --------122
*/
/* Rolling involves only neighbour that are currently snapping */
fail_unless (ges_timeline_element_roll_end (GES_TIMELINE_ELEMENT (clip1),
62));
fail_unless (ges_timeline_element_roll_end (GES_TIMELINE_ELEMENT (clip1),
72) == TRUE); 72) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); DEEP_CHECK (clip, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 20, 0, 52); DEEP_CHECK (clip1, 20, 0, 10);
CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50); DEEP_CHECK (clip2, 62, 0, 60);
/** /**
* 0---------- * 30-------+0-------------+
* | clip | * inpoints 0-----------5 clip || clip2 |
* 25---------62 * | clip1 |------- 62 -----------122
* inpoints 5--------------- 10-------- * time 20----------30
* | clip1 || clip2 |
* time 25------------- 72 --------122
*/ */
g_object_set (timeline, "snapping-distance", (guint64) 4, NULL); g_object_set (timeline, "snapping-distance", (guint64) 4, NULL);
fail_unless (ges_timeline_element_trim (GES_TIMELINE_ELEMENT (clip1), fail_unless (ges_timeline_element_trim (GES_TIMELINE_ELEMENT (clip),
28) == TRUE); 28) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); DEEP_CHECK (clip, 30, 5, 32);
CHECK_OBJECT_PROPS (trackelement1, 25, 5, 47); DEEP_CHECK (clip1, 20, 0, 10);
CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50); DEEP_CHECK (clip2, 62, 0, 60);
/** /**
* 0---------- * 30-------+0-------------+
* | clip | * inpoints 0-----------5 clip || clip2 |
* 25---------62 * | clip1 |------- 62 -----------122
* inpoints 5---------- 0--------- * time 20----------30
* | clip1 || clip2 |
* time 25-------- 62 --------122
*/ */
fail_unless (ges_timeline_element_set_inpoint (GES_TIMELINE_ELEMENT (clip2),
5));
fail_unless (ges_timeline_element_roll_start (GES_TIMELINE_ELEMENT (clip2), fail_unless (ges_timeline_element_roll_start (GES_TIMELINE_ELEMENT (clip2),
59) == TRUE); 60));
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); DEEP_CHECK (clip, 30, 5, 32);
CHECK_OBJECT_PROPS (trackelement1, 25, 5, 37); DEEP_CHECK (clip1, 20, 0, 10);
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60); DEEP_CHECK (clip2, 62, 5, 60);
/** /**
* 0---------- * 30-------+0-------------+
* | clip | * inpoints 0-----------5 clip || clip2 |
* 25--------62 * | clip1 |------- 62 -----------122
* inpoints 5-----------------------+ * time 20----------30
* | clip1 || clip2 |
* time 30------------]--------122
* 67
*/ */
ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_NORMAL, GES_EDGE_NONE, 30); /* Moving clip1 to 26 would lead to snapping to 30, and clip1 and clip
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); * would fully overlap */
CHECK_OBJECT_PROPS (trackelement1, 30, 5, 37); fail_if (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_NORMAL,
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60); GES_EDGE_NONE, 26) == TRUE);
DEEP_CHECK (clip, 30, 5, 32);
DEEP_CHECK (clip1, 20, 0, 10);
DEEP_CHECK (clip2, 62, 5, 60);
/** /**
* inpoints 0----------5-------------- * 30-------+0-------------+
* | clip || clip1 | * inpoints 5 clip || clip2 |-------------+
* time 25----------62----------99 * +------- 62 -----------122 clip1 |
* 0----------- * time +------------132
* | clip2 | * Check that clip1 snaps with the end of clip2 */
* 98--------168
* Check that clip1 snaps with the end of clip */
fail_unless (ges_timeline_element_ripple (GES_TIMELINE_ELEMENT (clip1),
58) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 62, 5, 37);
CHECK_OBJECT_PROPS (trackelement2, 94, 0, 60);
/**
* inpoints 0----------- 5------------ 0-----------
* | clip || clip1 | | clip2 |
* time 25----------62----------99 110--------170
*/
ges_container_edit (clip2, NULL, -1, GES_EDIT_MODE_NORMAL, GES_EDGE_NONE,
110);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 62, 5, 37);
CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/**
* inpoints 0----------5 5 --------- 0----------
* | clip | | clip1 || clip2 |
* time 25---------62 73---------110--------170
*/
fail_unless (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_NORMAL, fail_unless (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, 72) == TRUE); GES_EDGE_NONE, 125) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); DEEP_CHECK (clip, 30, 5, 32);
CHECK_OBJECT_PROPS (trackelement1, 73, 5, 37); DEEP_CHECK (clip1, 122, 0, 10);
CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60); DEEP_CHECK (clip2, 62, 5, 60);
/**
* inpoints 0----------5---------- 0----------
* | clip || clip1 | | clip2 |
* time 25---------62-------- 99 110--------170
*/
fail_unless (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, 58) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 62, 5, 37);
CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/**
* inpoints 0----------5---------- 0----------
* | clip || clip1 || clip2 |
* time 25---------62--------110--------170
*/
g_object_set (clip1, "duration", (guint64) 46, NULL);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 62, 5, 48);
CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/**
* inpoints 5----------- 0--------- 0----------
* | clip1 || clip2 || clip |
* time 62---------110--------170--------207
*/
ges_container_edit (clip, NULL, -1, GES_EDIT_MODE_NORMAL, GES_EDGE_NONE, 168);
CHECK_OBJECT_PROPS (trackelement, 170, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 62, 5, 48);
CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/* Check we didn't lose/screwed any references */ /* Check we didn't lose/screwed any references */
ASSERT_OBJECT_REFCOUNT (trackelement, "First trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "First trackelement", 3);
ASSERT_OBJECT_REFCOUNT (trackelement1, "Second trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement1, "Second trackelement", 3);
ASSERT_OBJECT_REFCOUNT (trackelement2, "Third trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement2, "Third trackelement", 3);
ASSERT_OBJECT_REFCOUNT (clip, "First clip", 2); ASSERT_OBJECT_REFCOUNT (clip, "First clip", 2);
ASSERT_OBJECT_REFCOUNT (clip1, "Second clip", 2); ASSERT_OBJECT_REFCOUNT (clip1, "Second clip", 2);
ASSERT_OBJECT_REFCOUNT (clip2, "Third clip", 2); ASSERT_OBJECT_REFCOUNT (clip2, "Third clip", 2);
@ -782,6 +717,15 @@ GST_START_TEST (test_timeline_edition_mode)
assert_equals_int (ges_layer_get_priority (layer), 2); assert_equals_int (ges_layer_get_priority (layer), 2);
gst_object_unref (layer); gst_object_unref (layer);
/* Roll end clip back to 35 */
/* Can not move to the first layer as clip2 should move to a layer with priority < 0 */
fail_if (ges_container_edit (clip, NULL, 0, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 52));
CHECK_OBJECT_PROPS (trackelement, 32, 5, 3);
CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
assert_equals_int (GES_TIMELINE_ELEMENT_LAYER_PRIORITY (clip), 2);
/* Ripple clip end to 52 /* Ripple clip end to 52
* New timeline: * New timeline:
* ------------ * ------------
@ -795,8 +739,7 @@ GST_START_TEST (test_timeline_edition_mode)
* 32------52 * 32------52
* *
*/ */
/* Can not move to the first layer as clip2 should move to a layer with priority < 0 */ fail_unless (ges_container_edit (clip, NULL, -1, GES_EDIT_MODE_RIPPLE,
fail_unless (ges_container_edit (clip, NULL, 0, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 52) == TRUE); GES_EDGE_END, 52) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 32, 5, 20); CHECK_OBJECT_PROPS (trackelement, 32, 5, 20);
CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10); CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
@ -817,9 +760,9 @@ GST_START_TEST (test_timeline_edition_mode)
/* We have 3 references: /* We have 3 references:
* track + timeline + clip * track + timeline + clip
*/ */
ASSERT_OBJECT_REFCOUNT (trackelement, "First trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement, "First trackelement", 3);
ASSERT_OBJECT_REFCOUNT (trackelement1, "Second trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement1, "Second trackelement", 3);
ASSERT_OBJECT_REFCOUNT (trackelement2, "Third trackelement", 4); ASSERT_OBJECT_REFCOUNT (trackelement2, "Third trackelement", 3);
ASSERT_OBJECT_REFCOUNT (clip, "First clip", 2); ASSERT_OBJECT_REFCOUNT (clip, "First clip", 2);
ASSERT_OBJECT_REFCOUNT (clip1, "Second clip", 2); ASSERT_OBJECT_REFCOUNT (clip1, "Second clip", 2);
ASSERT_OBJECT_REFCOUNT (clip2, "Third clip", 2); ASSERT_OBJECT_REFCOUNT (clip2, "Third clip", 2);
@ -904,16 +847,13 @@ GST_START_TEST (test_timeline_edition_mode)
/* Snaping to edge, so no move */ /* Snaping to edge, so no move */
g_object_set (timeline, "snapping-distance", (guint64) 3, NULL); g_object_set (timeline, "snapping-distance", (guint64) 3, NULL);
fail_if (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_TRIM, ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, 27);
GES_EDGE_END, 27));
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5); CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60); CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Snaping to edge, so no move */ /* Snaping to edge, so no move */
fail_if (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_TRIM, ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, 27);
GES_EDGE_END, 27));
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5); CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60); CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
@ -939,13 +879,13 @@ GST_START_TEST (test_timeline_edition_mode)
* 0---------- * 0----------
* | clip | * | clip |
* 25---------62 * 25---------62
* -------------------------------------------------
* inpoints 0----------------------- 10-------- * inpoints 0----------------------- 10--------
* | clip1 || clip2 | * | clip1 || clip2 |
* time 20---------------------- 72 --------122 * time 20---------------------- 72 --------122
*/ */
/* Rolling involves only neighbours that are currently snapping */ /* Rolling involves only neighbours that are currently snapping */
fail_unless (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_ROLL, ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_ROLL, GES_EDGE_END, 62);
GES_EDGE_END, 62) == TRUE);
fail_unless (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_ROLL, fail_unless (ges_container_edit (clip1, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_END, 72) == TRUE); GES_EDGE_END, 72) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37); CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
@ -968,19 +908,8 @@ GST_START_TEST (test_timeline_edition_mode)
CHECK_OBJECT_PROPS (trackelement1, 25, 5, 47); CHECK_OBJECT_PROPS (trackelement1, 25, 5, 47);
CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50); CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50);
/** fail_if (ges_container_edit (clip2, NULL, -1, GES_EDIT_MODE_ROLL,
* 0---------- GES_EDGE_START, 59));
* | clip |
* 25---------62
* inpoints 5---------- 0---------
* | clip1 || clip2 |
* time 25-------- 62 --------122
*/
fail_unless (ges_container_edit (clip2, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_START, 59) == TRUE);
CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
CHECK_OBJECT_PROPS (trackelement1, 25, 5, 37);
CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
ges_deinit (); ges_deinit ();
} }
@ -1040,131 +969,70 @@ GST_START_TEST (test_groups)
g_list_free (clips); g_list_free (clips);
fail_unless (GES_IS_GROUP (group)); fail_unless (GES_IS_GROUP (group));
DEEP_CHECK (c, 0, 0, 10); CHECK_CLIP (c, 0, 0, 10, 0);
DEEP_CHECK (c1, 10, 0, 10); CHECK_CLIP (c1, 10, 0, 10, 1);
DEEP_CHECK (c2, 20, 0, 10); CHECK_CLIP (c2, 20, 0, 10, 1);
CHECK_OBJECT_PROPS (group, 0, 0, 30); CHECK_OBJECT_PROPS (group, 0, 0, 30);
c3 = ges_layer_add_asset (layer, asset, 30, 0, 20, GES_TRACK_TYPE_UNKNOWN); c3 = ges_layer_add_asset (layer, asset, 30, 0, 20, GES_TRACK_TYPE_UNKNOWN);
c4 = ges_layer_add_asset (layer1, asset, 40, 0, 20, GES_TRACK_TYPE_UNKNOWN); c4 = ges_layer_add_asset (layer1, asset, 40, 0, 20, GES_TRACK_TYPE_UNKNOWN);
c5 = ges_layer_add_asset (layer2, asset, 50, 0, 20, GES_TRACK_TYPE_UNKNOWN); c5 = ges_layer_add_asset (layer2, asset, 50, 0, 20, GES_TRACK_TYPE_UNKNOWN);
DEEP_CHECK (c3, 30, 0, 20); CHECK_CLIP (c3, 30, 0, 20, 0);
DEEP_CHECK (c4, 40, 0, 20); CHECK_CLIP (c4, 40, 0, 20, 1);
DEEP_CHECK (c5, 50, 0, 20); CHECK_CLIP (c5, 50, 0, 20, 2);
check_layer (c, 0); check_layer (c, 0);
check_layer (c1, 1); check_layer (c1, 1);
check_layer (c2, 1); check_layer (c2, 1);
check_layer (c3, 0);
check_layer (c4, 1);
check_layer (c5, 2);
fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, -1, fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, -1,
GES_EDIT_MODE_RIPPLE, GES_EDGE_NONE, 10) == TRUE); GES_EDIT_MODE_RIPPLE, GES_EDGE_NONE, 10) == TRUE);
DEEP_CHECK (c, 10, 0, 10); CHECK_CLIP (c, 10, 0, 10, 0);
DEEP_CHECK (c1, 10, 0, 10); CHECK_CLIP (c1, 20, 0, 10, 1);
DEEP_CHECK (c2, 30, 0, 10); CHECK_CLIP (c2, 30, 0, 10, 1);
DEEP_CHECK (c3, 40, 0, 20); CHECK_CLIP (c3, 40, 0, 20, 0);
DEEP_CHECK (c4, 50, 0, 20); CHECK_CLIP (c4, 50, 0, 20, 1);
DEEP_CHECK (c5, 60, 0, 20); CHECK_CLIP (c5, 60, 0, 20, 2);
check_layer (c, 0);
check_layer (c1, 1);
check_layer (c2, 1);
check_layer (c3, 0);
check_layer (c4, 1);
check_layer (c5, 2);
fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, 1, fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, 1,
GES_EDIT_MODE_RIPPLE, GES_EDGE_NONE, 10) == TRUE); GES_EDIT_MODE_RIPPLE, GES_EDGE_NONE, 10) == TRUE);
DEEP_CHECK (c, 10, 0, 10); CHECK_CLIP (c, 10, 0, 10, 1);
DEEP_CHECK (c1, 10, 0, 10); CHECK_CLIP (c1, 20, 0, 10, 2);
DEEP_CHECK (c2, 30, 0, 10); CHECK_CLIP (c2, 30, 0, 10, 2);
DEEP_CHECK (c3, 40, 0, 20); CHECK_CLIP (c3, 40, 0, 20, 1);
DEEP_CHECK (c4, 50, 0, 20); CHECK_CLIP (c4, 50, 0, 20, 2);
DEEP_CHECK (c5, 60, 0, 20); CHECK_CLIP (c5, 60, 0, 20, 3);
check_layer (c, 1);
check_layer (c1, 2);
check_layer (c2, 2);
check_layer (c3, 1);
check_layer (c4, 2);
check_layer (c5, 3);
fail_unless (ges_container_edit (GES_CONTAINER (c1), NULL, 2, fail_if (ges_container_edit (GES_CONTAINER (c1), NULL, 2,
GES_EDIT_MODE_RIPPLE, GES_EDGE_END, 40) == TRUE); GES_EDIT_MODE_RIPPLE, GES_EDGE_END, 40) == TRUE);
DEEP_CHECK (c, 10, 0, 10); fail_if (ges_container_edit (GES_CONTAINER (c1), NULL, 2,
DEEP_CHECK (c1, 10, 0, 30);
DEEP_CHECK (c2, 50, 0, 10);
DEEP_CHECK (c3, 60, 0, 20);
DEEP_CHECK (c4, 70, 0, 20);
DEEP_CHECK (c5, 80, 0, 20);
check_layer (c, 1);
check_layer (c1, 2);
check_layer (c2, 2);
check_layer (c3, 1);
check_layer (c4, 2);
check_layer (c5, 3);
fail_unless (ges_container_edit (GES_CONTAINER (c1), NULL, 2,
GES_EDIT_MODE_RIPPLE, GES_EDGE_END, 30) == TRUE); GES_EDIT_MODE_RIPPLE, GES_EDGE_END, 30) == TRUE);
DEEP_CHECK (c, 10, 0, 10); CHECK_CLIP (c, 10, 0, 10, 1);
DEEP_CHECK (c1, 10, 0, 20); CHECK_CLIP (c1, 20, 0, 10, 2);
DEEP_CHECK (c2, 40, 0, 10); CHECK_CLIP (c2, 30, 0, 10, 2);
DEEP_CHECK (c3, 50, 0, 20); CHECK_CLIP (c3, 40, 0, 20, 1);
DEEP_CHECK (c4, 60, 0, 20); CHECK_CLIP (c4, 50, 0, 20, 2);
DEEP_CHECK (c5, 70, 0, 20); CHECK_CLIP (c5, 60, 0, 20, 3);
check_layer (c, 1);
check_layer (c1, 2);
check_layer (c2, 2);
check_layer (c3, 1);
check_layer (c4, 2);
check_layer (c5, 3);
fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, 0, fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, 0,
GES_EDIT_MODE_RIPPLE, GES_EDGE_NONE, 0) == TRUE); GES_EDIT_MODE_RIPPLE, GES_EDGE_NONE, 0) == TRUE);
DEEP_CHECK (c, 0, 0, 10); CHECK_CLIP (c, 0, 0, 10, 0);
DEEP_CHECK (c1, 10, 0, 20); CHECK_CLIP (c1, 10, 0, 10, 1);
DEEP_CHECK (c2, 30, 0, 10); CHECK_CLIP (c2, 20, 0, 10, 1);
DEEP_CHECK (c3, 40, 0, 20); CHECK_CLIP (c3, 30, 0, 20, 0);
DEEP_CHECK (c4, 50, 0, 20); CHECK_CLIP (c4, 40, 0, 20, 1);
DEEP_CHECK (c5, 60, 0, 20); CHECK_CLIP (c5, 50, 0, 20, 2);
check_layer (c, 0); CHECK_OBJECT_PROPS (group, 0, 0, 30);
check_layer (c1, 1);
check_layer (c2, 1);
check_layer (c3, 0);
check_layer (c4, 1);
check_layer (c5, 2);
fail_if (ges_container_edit (GES_CONTAINER (c2), NULL, -1,
GES_EDIT_MODE_ROLL, GES_EDGE_END, 40) == TRUE);
DEEP_CHECK (c, 0, 0, 10);
DEEP_CHECK (c1, 10, 0, 20);
DEEP_CHECK (c2, 30, 0, 10);
DEEP_CHECK (c3, 40, 0, 20);
DEEP_CHECK (c4, 50, 0, 20);
DEEP_CHECK (c5, 60, 0, 20);
check_layer (c, 0);
check_layer (c1, 1);
check_layer (c2, 1);
check_layer (c3, 0);
check_layer (c4, 1);
check_layer (c5, 2);
fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, 0, fail_unless (ges_container_edit (GES_CONTAINER (c), NULL, 0,
GES_EDIT_MODE_TRIM, GES_EDGE_START, 5) == TRUE); GES_EDIT_MODE_TRIM, GES_EDGE_START, 5) == TRUE);
CHECK_OBJECT_PROPS (c, 5, 5, 5); CHECK_CLIP (c, 5, 5, 5, 0);
DEEP_CHECK (c1, 10, 0, 20); CHECK_CLIP (c1, 10, 0, 10, 1);
DEEP_CHECK (c2, 30, 0, 10); CHECK_CLIP (c2, 20, 0, 10, 1);
DEEP_CHECK (c3, 40, 0, 20); CHECK_CLIP (c3, 30, 0, 20, 0);
DEEP_CHECK (c4, 50, 0, 20); CHECK_CLIP (c4, 40, 0, 20, 1);
DEEP_CHECK (c5, 60, 0, 20); CHECK_CLIP (c5, 50, 0, 20, 2);
CHECK_OBJECT_PROPS (group, 5, 0, 35); CHECK_OBJECT_PROPS (group, 5, 0, 25);
check_layer (c, 0);
check_layer (c1, 1);
check_layer (c2, 1);
check_layer (c3, 0);
check_layer (c4, 1);
check_layer (c5, 2);
gst_object_unref (timeline); gst_object_unref (timeline);
gst_object_unref (asset); gst_object_unref (asset);

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

@ -263,7 +263,7 @@ GST_START_TEST (test_filesource_images)
fail_unless (GES_IS_IMAGE_SOURCE (track_element)); fail_unless (GES_IS_IMAGE_SOURCE (track_element));
ASSERT_OBJECT_REFCOUNT (track_element, "1 in track, 1 in clip 2 in timeline", ASSERT_OBJECT_REFCOUNT (track_element, "1 in track, 1 in clip 2 in timeline",
4); 3);
gst_object_unref (asset); gst_object_unref (asset);
gst_object_unref (timeline); gst_object_unref (timeline);

21
tests/check/python/common.py
View file

@ -194,7 +194,16 @@ class GESSimpleTimelineTest(GESTest):
return clip return clip
def assertTimelineTopology(self, topology): def append_clip(self, layer=0):
layer = self.timeline.get_layers()[layer]
clip = GES.TestClip()
clip.props.start = layer.get_duration()
clip.props.duration = 10
self.assertTrue(layer.add_clip(clip))
return clip
def assertTimelineTopology(self, topology, groups=[]):
res = [] res = []
for layer in self.timeline.get_layers(): for layer in self.timeline.get_layers():
layer_timings = [] layer_timings = []
@ -203,6 +212,14 @@ class GESSimpleTimelineTest(GESTest):
(type(clip), clip.props.start, clip.props.duration)) (type(clip), clip.props.start, clip.props.duration))
res.append(layer_timings) res.append(layer_timings)
if topology != res:
Gst.error(self.timeline_as_str())
self.assertEqual(topology, res) self.assertEqual(topology, res)
timeline_groups = self.timeline.get_groups()
if groups and timeline_groups:
for i, group in enumerate(groups):
self.assertEqual(set(group), set(timeline_groups[i].get_children(False)))
self.assertEqual(len(timeline_groups), i + 1)
return res return res

86
tests/check/python/test_group.py
View file

@ -251,6 +251,8 @@ class TestGroup(common.GESSimpleTimelineTest):
self.assertEqual(audio_transition.props.duration, 10) self.assertEqual(audio_transition.props.duration, 10)
def test_moving_group_snapping_from_the_middle(self): def test_moving_group_snapping_from_the_middle(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
snapped_positions = [] snapped_positions = []
def snapping_started_cb(timeline, first_element, second_element, def snapping_started_cb(timeline, first_element, second_element,
position, snapped_positions): position, snapped_positions):
@ -272,10 +274,88 @@ class TestGroup(common.GESSimpleTimelineTest):
group = GES.Container.group(clips[1:3]) group = GES.Container.group(clips[1:3])
self.assertIsNotNone(group) self.assertIsNotNone(group)
self.assertTimelineTopology([
[
(GES.TestClip, 0, 5),
(GES.TestClip, 5, 5),
(GES.TestClip, 10, 5),
(GES.TestClip, 15, 5),
],
], groups=[clips[1:3]])
self.assertEqual(clips[1].props.start, 5) self.assertEqual(clips[1].props.start, 5)
self.assertEqual(clips[2].props.start, 10) self.assertEqual(clips[2].props.start, 10)
clips[2].edit([], 0, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, 11) clips[2].edit([], 0, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, 11)
self.assertEqual(snapped_positions[0], clips[2].start + clips[2].duration) self.assertEqual(snapped_positions[0], 5)
self.assertEqual(clips[1].props.start, 5) self.assertTimelineTopology([
self.assertEqual(clips[2].props.start, 10) [
(GES.TestClip, 0, 5),
(GES.TestClip, 5, 5),
(GES.TestClip, 10, 5),
(GES.TestClip, 15, 5),
],
], groups=[clips[1:3]])
def test_rippling_with_group(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
for _ in range(4):
self.append_clip()
snapped_positions = []
def snapping_started_cb(timeline, first_element, second_element,
position, snapped_positions):
snapped_positions.append(position)
self.timeline.props.snapping_distance = 5
self.timeline.connect("snapping-started", snapping_started_cb,
snapped_positions)
clips = self.layer.get_clips()
self.assertEqual(len(clips), 4)
group_clips = clips[1:3]
GES.Container.group(group_clips)
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
],
], groups=[group_clips])
self.assertFalse(clips[2].edit([], 0, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 5))
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
],
], groups=[group_clips])
# Negative start...
self.assertFalse(clips[2].edit([], 1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 1))
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
],
], groups=[group_clips])
self.assertTrue(clips[2].edit([], 1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 20))
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
],
[
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
],
], groups=[group_clips])

640
tests/check/python/test_timeline.py
View file

@ -35,7 +35,7 @@ Gst.init(None)
GES.init() GES.init()
class TestTimeline(unittest.TestCase): class TestTimeline(common.GESSimpleTimelineTest):
def test_signals_not_emitted_when_loading(self): def test_signals_not_emitted_when_loading(self):
mainloop = common.create_main_loop() mainloop = common.create_main_loop()
@ -63,13 +63,31 @@ class TestTimeline(unittest.TestCase):
self.assertTrue(loaded_called) self.assertTrue(loaded_called)
handle.assert_not_called() handle.assert_not_called()
def test_timeline_duration(self):
self.append_clip()
self.append_clip()
clips = self.layer.get_clips()
class TestSplitting(common.GESSimpleTimelineTest): self.assertEqual(self.timeline.props.duration, 20)
def setUp(self): self.layer.remove_clip(clips[1])
self.track_types = [GES.TrackType.AUDIO] self.assertEqual(self.timeline.props.duration, 10)
super(TestSplitting, self).setUp()
self.append_clip()
self.append_clip()
clips = self.layer.get_clips()
self.assertEqual(self.timeline.props.duration, 30)
group = GES.Container.group(clips[1:])
self.assertEqual(self.timeline.props.duration, 30)
group1 = GES.Container.group([])
group1.add(group)
self.assertEqual(self.timeline.props.duration, 30)
def test_spliting_with_auto_transition_on_the_left(self): def test_spliting_with_auto_transition_on_the_left(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
self.timeline.props.auto_transition = True self.timeline.props.auto_transition = True
clip1 = self.add_clip(0, 0, 100) clip1 = self.add_clip(0, 0, 100)
clip2 = self.add_clip(50, 0, 100) clip2 = self.add_clip(50, 0, 100)
@ -117,6 +135,102 @@ class TestEditing(common.GESSimpleTimelineTest):
self.assertEqual(len(self.layer.get_clips()), 1) self.assertEqual(len(self.layer.get_clips()), 1)
self.assertEqual(len(layer2.get_clips()), 1) self.assertEqual(len(layer2.get_clips()), 1)
def activate_snapping(self):
self.timeline.set_snapping_distance(5)
self.snapped_at = []
def _snapped_cb(timeline, elem1, elem2, position):
self.snapped_at.append(position)
Gst.error('%s' % position)
def _snapped_end_cb(timeline, elem1, elem2, position):
if self.snapped_at: # Ignoring first snap end.
self.snapped_at.append(Gst.CLOCK_TIME_NONE)
Gst.error('%s' % position)
self.timeline.connect("snapping-started", _snapped_cb)
self.timeline.connect("snapping-ended", _snapped_end_cb)
def test_snap_start_snap_end(self):
clip = self.append_clip()
self.append_clip()
self.activate_snapping()
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
clip.props.start = 18
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
]
])
self.assertEqual(self.snapped_at, [20])
clip.props.start = 30
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 10, 10),
(GES.TestClip, 30, 10),
]
])
self.assertEqual(self.snapped_at, [20, Gst.CLOCK_TIME_NONE])
clip.props.start = 18
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
]
])
self.assertEqual(self.snapped_at, [20, Gst.CLOCK_TIME_NONE,
Gst.CLOCK_TIME_NONE, 20])
clip.props.start = 19
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
]
])
self.assertEqual(self.snapped_at, [20, Gst.CLOCK_TIME_NONE,
Gst.CLOCK_TIME_NONE, 20])
def test_rippling_snaps(self):
self.timeline.props.auto_transition = True
self.append_clip()
clip = self.append_clip()
self.activate_snapping()
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
clip.edit([], 0, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 15)
self.assertEqual(self.snapped_at, [10])
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
clip.edit([], 0, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 20)
self.assertEqual(self.snapped_at, [10, Gst.CLOCK_TIME_NONE])
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 20, 10),
]
])
def test_transition_moves_when_rippling_to_another_layer(self): def test_transition_moves_when_rippling_to_another_layer(self):
self.timeline.props.auto_transition = True self.timeline.props.auto_transition = True
clip1 = self.add_clip(0, 0, 100) clip1 = self.add_clip(0, 0, 100)
@ -160,6 +274,451 @@ class TestEditing(common.GESSimpleTimelineTest):
GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 35 * Gst.SECOND) GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 35 * Gst.SECOND)
self.assertEqual(len(self.layer.get_clips()), 4) self.assertEqual(len(self.layer.get_clips()), 4)
def test_trim_transition(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
self.timeline.props.auto_transition = True
self.add_clip(0, 0, 10)
self.add_clip(5, 0, 10)
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TransitionClip, 5, 5),
(GES.TestClip, 5, 10),
]
])
transition = self.layer.get_clips()[1]
self.assertTrue(transition.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, 7))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TransitionClip, 7, 3),
(GES.TestClip, 7, 8),
]
])
def test_trim_start(self):
clip = self.append_clip()
self.assertTrue(clip.edit([], -1, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, 10))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 10, 10),
]
])
self.assertFalse(clip.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_NONE, 0))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 10, 10),
]
])
def test_ripple_end(self):
clip = self.append_clip()
clip.set_max_duration(20)
self.append_clip().set_max_duration(10)
self.append_clip().set_max_duration(10)
self.print_timeline()
self.assertTrue(clip.edit([], -1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_END, 20))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 20),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
]
])
self.assertTrue(clip.edit([], -1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_END, 15))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 15),
(GES.TestClip, 15, 10),
(GES.TestClip, 25, 10),
]
])
def test_move_group_full_overlap(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
for _ in range(4):
self.append_clip()
clips = self.layer.get_clips()
self.assertTrue(clips[0].ripple(20))
self.assertTimelineTopology([
[
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
(GES.TestClip, 40, 10),
(GES.TestClip, 50, 10),
]
])
group = GES.Container.group(clips[1:])
self.print_timeline()
self.assertFalse(group.edit([], -1, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, 0))
self.print_timeline()
self.assertTimelineTopology([
[
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
(GES.TestClip, 40, 10),
(GES.TestClip, 50, 10),
]
])
self.assertFalse(clips[1].edit([], -1, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, 0))
self.print_timeline()
self.assertTimelineTopology([
[
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
(GES.TestClip, 40, 10),
(GES.TestClip, 50, 10),
]
])
def test_trim_inside_group(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
for _ in range(2):
self.append_clip()
clips = self.layer.get_clips()
group = GES.Container.group(clips)
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
self.assertEqual(group.props.start, 0)
self.assertEqual(group.props.duration, 20)
clips[0].trim(5)
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 5, 5),
(GES.TestClip, 10, 10),
]
])
self.assertEqual(group.props.start, 5)
self.assertEqual(group.props.duration, 15)
def test_trim_end_past_max_duration(self):
clip = self.append_clip()
max_duration = clip.props.duration
clip.set_max_duration(max_duration)
self.assertTrue(clip.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, 5))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 5, 5),
]
])
self.assertFalse(clip.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_END, 15))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 5, 5),
]
])
class TestInvalidOverlaps(common.GESSimpleTimelineTest):
def test_adding_or_moving(self):
clip1 = self.add_clip(start=10, in_point=0, duration=3)
self.assertIsNotNone(clip1)
def check_add_move_clip(start, duration):
self.timeline.props.auto_transition = True
self.layer.props.auto_transition = True
clip2 = GES.TestClip()
clip2.props.start = start
clip2.props.duration = duration
self.assertFalse(self.layer.add_clip(clip2))
self.assertEqual(len(self.layer.get_clips()), 1)
# Add the clip at a different position.
clip2.props.start = 25
self.assertTrue(self.layer.add_clip(clip2))
self.assertEqual(clip2.props.start, 25)
# Try to move the second clip by editing it.
self.assertFalse(clip2.edit([], -1, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, start))
self.assertEqual(clip2.props.start, 25)
# Try to put it in a group and move the group.
clip3 = GES.TestClip()
clip3.props.start = 20
clip3.props.duration = 1
self.assertTrue(self.layer.add_clip(clip3))
group = GES.Container.group([clip3, clip2])
self.assertTrue(group.props.start, 20)
self.assertFalse(group.edit([], -1, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, start - 5))
self.assertEqual(group.props.start, 20)
self.assertEqual(clip3.props.start, 20)
self.assertEqual(clip2.props.start, 25)
for clip in group.ungroup(False):
self.assertTrue(self.layer.remove_clip(clip))
# clip1 contains...
check_add_move_clip(start=10, duration=1)
check_add_move_clip(start=11, duration=1)
check_add_move_clip(start=12, duration=1)
def test_splitting(self):
clip1 = self.add_clip(start=9, in_point=0, duration=3)
clip2 = self.add_clip(start=10, in_point=0, duration=4)
clip3 = self.add_clip(start=12, in_point=0, duration=3)
self.assertIsNone(clip1.split(13))
self.assertIsNone(clip1.split(8))
self.assertIsNone(clip3.split(12))
self.assertIsNone(clip3.split(15))
def test_changing_duration(self):
clip1 = self.add_clip(start=9, in_point=0, duration=2)
clip2 = self.add_clip(start=10, in_point=0, duration=2)
self.assertFalse(clip1.set_start(10))
self.assertFalse(clip1.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_END, clip2.props.start + clip2.props.duration))
self.assertFalse(clip1.ripple_end(clip2.props.start + clip2.props.duration))
self.assertFalse(clip1.roll_end(clip2.props.start + clip2.props.duration))
# clip2's end edge to the left, to decrease its duration.
self.assertFalse(clip2.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_END, clip1.props.start + clip1.props.duration))
self.assertFalse(clip2.ripple_end(clip1.props.start + clip1.props.duration))
self.assertFalse(clip2.roll_end(clip1.props.start + clip1.props.duration))
# clip2's start edge to the left, to increase its duration.
self.assertFalse(clip2.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, clip1.props.start))
self.assertFalse(clip2.trim(clip1.props.start))
# clip1's start edge to the right, to decrease its duration.
self.assertFalse(clip1.edit([], -1, GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, clip2.props.start))
self.assertFalse(clip1.trim(clip2.props.start))
def test_rippling_backward(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
self.maxDiff = None
for i in range(4):
self.append_clip()
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
]
])
clip = self.layer.get_clips()[2]
self.assertFalse(clip.edit([], -1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, clip.props.start - 20))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
]
])
self.assertTrue(clip.edit([], -1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, clip.props.start + 10))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
(GES.TestClip, 30, 10),
(GES.TestClip, 40, 10),
]
])
self.assertFalse(clip.edit([], -1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, clip.props.start -20))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
(GES.TestClip, 30, 10),
(GES.TestClip, 40, 10),
]
])
def test_rolling(self):
clip1 = self.add_clip(start=9, in_point=0, duration=2)
clip2 = self.add_clip(start=10, in_point=0, duration=2)
clip3 = self.add_clip(start=11, in_point=0, duration=2)
# Rolling clip1's end -1 would lead to clip3 to overlap 100% with clip2.
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 9, 2),
(GES.TestClip, 10, 2),
(GES.TestClip, 11, 2)
]
])
self.assertFalse(clip1.edit([], -1, GES.EditMode.EDIT_ROLL, GES.Edge.EDGE_END, clip1.props.start + clip1.props.duration - 1))
self.assertFalse(clip1.roll_end(13))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 9, 2),
(GES.TestClip, 10, 2),
(GES.TestClip, 11, 2)
]
])
# Rolling clip3's start +1 would lead to clip1 to overlap 100% with clip2.
self.assertFalse(clip3.edit([], -1, GES.EditMode.EDIT_ROLL, GES.Edge.EDGE_START, 12))
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 9, 2),
(GES.TestClip, 10, 2),
(GES.TestClip, 11, 2)
]
])
def test_layers(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
self.maxDiff = None
self.timeline.append_layer()
for i in range(2):
self.append_clip()
self.append_clip(1)
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
],
[
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
clip = self.layer.get_clips()[0]
self.assertFalse(clip.edit([], 1, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, 0))
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
],
[
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
def test_rippling(self):
self.timeline.remove_track(self.timeline.get_tracks()[0])
clip1 = self.add_clip(start=9, in_point=0, duration=2)
clip2 = self.add_clip(start=10, in_point=0, duration=2)
clip3 = self.add_clip(start=11, in_point=0, duration=2)
# Rippling clip2's start -2 would bring clip3 exactly on top of clip1.
self.assertFalse(clip2.edit([], -1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_NONE, 8))
self.assertFalse(clip2.ripple(8))
# Rippling clip1's end -1 would bring clip3 exactly on top of clip2.
self.assertFalse(clip1.edit([], -1, GES.EditMode.EDIT_RIPPLE, GES.Edge.EDGE_END, 8))
self.assertFalse(clip1.ripple_end(8))
def test_move_group_to_layer(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
self.append_clip()
self.append_clip()
self.append_clip()
clips = self.layer.get_clips()
clips[1].props.start += 2
group = GES.Container.group(clips[1:])
self.assertTrue(clips[1].edit([], 1, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE,
group.props.start))
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
],
[
(GES.TestClip, 12, 10),
(GES.TestClip, 20, 10),
]
])
clips[0].props.start = 15
self.assertTimelineTopology([
[
(GES.TestClip, 15, 10),
],
[
(GES.TestClip, 12, 10),
(GES.TestClip, 20, 10),
]
])
self.assertFalse(clips[1].edit([], 0, GES.EditMode.EDIT_NORMAL,
GES.Edge.EDGE_NONE, group.props.start))
self.assertTimelineTopology([
[
(GES.TestClip, 15, 10),
],
[
(GES.TestClip, 12, 10),
(GES.TestClip, 20, 10),
]
])
def test_move_group_with_overlaping_clips(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
self.append_clip()
self.append_clip()
self.append_clip()
self.timeline.props.auto_transition = True
clips = self.layer.get_clips()
clips[1].props.start += 5
group = GES.Container.group(clips[1:])
self.assertTimelineTopology([
[
(GES.TestClip, 0, 10),
(GES.TestClip, 15, 10),
(GES.TransitionClip, 20, 5),
(GES.TestClip, 20, 10),
]
])
clips[0].props.start = 30
self.assertTimelineTopology([
[
(GES.TestClip, 15, 10),
(GES.TransitionClip, 20, 5),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
]
])
# the 3 clips would overlap
self.assertFalse(clips[1].edit([], 0, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE, 25))
self.assertTimelineTopology([
[
(GES.TestClip, 15, 10),
(GES.TransitionClip, 20, 5),
(GES.TestClip, 20, 10),
(GES.TestClip, 30, 10),
]
])
class TestSnapping(common.GESSimpleTimelineTest): class TestSnapping(common.GESSimpleTimelineTest):
@ -180,14 +739,77 @@ class TestSnapping(common.GESSimpleTimelineTest):
clip2.props.start - 1) clip2.props.start - 1)
self.assertEqual(clip2.props.start, split_position) self.assertEqual(clip2.props.start, split_position)
def test_trim_snapps_inside_group(self):
self.track_types = [GES.TrackType.AUDIO]
super().setUp()
self.timeline.props.auto_transition = True
self.timeline.set_snapping_distance(5)
snaps = []
def snapping_started_cb(timeline, element1, element2, dist, self):
snaps.append(set([element1, element2]))
self.timeline.connect('snapping-started', snapping_started_cb, self)
clip = self.append_clip()
clip1 = self.append_clip()
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
clip1.edit([], self.layer.get_priority(), GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, 15)
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 10, 10),
]
])
self.assertEqual(snaps[0], set([clip.get_children(False)[0], clip1.get_children(False)[0]]))
clip1.edit([], self.layer.get_priority(), GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, 16)
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 0, 10),
(GES.TestClip, 16, 4),
]
])
def test_trim_no_snapping_on_same_clip(self):
self.timeline.props.auto_transition = True
self.timeline.set_snapping_distance(1)
not_called = []
def snapping_started_cb(timeline, element1, element2, dist, self):
not_called.append("No snapping should happen")
self.timeline.connect('snapping-started', snapping_started_cb, self)
clip = self.append_clip()
clip.edit([], self.layer.get_priority(), GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, 5)
self.assertEqual(not_called, [])
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 5, 5),
]
])
clip.edit([], self.layer.get_priority(), GES.EditMode.EDIT_TRIM, GES.Edge.EDGE_START, 4)
self.assertEqual(not_called, [])
self.assertTimelineTopology([
[ # Unique layer
(GES.TestClip, 4, 6),
]
])
def test_no_snapping_on_split(self): def test_no_snapping_on_split(self):
self.timeline.props.auto_transition = True self.timeline.props.auto_transition = True
self.timeline.set_snapping_distance(1) self.timeline.set_snapping_distance(1)
not_called = [] not_called = []
def snapping_started_cb(timeline, element1, element2, dist, self): def snapping_started_cb(timeline, element1, element2, dist, self):
Gst.error("Here %s %s" % (Gst.TIME_ARGS(element1.props.start + element1.props.duration),
Gst.TIME_ARGS(element2.props.start)))
not_called.append("No snapping should happen") not_called.append("No snapping should happen")
self.timeline.connect('snapping-started', snapping_started_cb, self) self.timeline.connect('snapping-started', snapping_started_cb, self)
@ -296,9 +918,9 @@ class TestTransitions(common.GESSimpleTimelineTest):
self.assertLess(clip1.props.start + clip1.props.duration, clip2.props.start + clip2.props.duration) self.assertLess(clip1.props.start + clip1.props.duration, clip2.props.start + clip2.props.duration)
self.assertEqual(len(clips), 3) self.assertEqual(len(clips), 3)
# Even though 3 clips overlap 1 transition will be created # 3 clips would be overlapping, 1 of them wasn't added!
clips = layers[1].get_clips() clips = layers[1].get_clips()
self.assertEqual(len(clips), 4) self.assertEqual(len(clips), 3)
class TestPriorities(common.GESSimpleTimelineTest): class TestPriorities(common.GESSimpleTimelineTest):