/* GStreamer Editing Services * Copyright (C) 2009 Edward Hervey <bilboed@bilboed.com> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "test-utils.h" #include "../../../ges/ges-structured-interface.h" #include <ges/ges.h> #include <gst/check/gstcheck.h> #define _assert_add(clip, child) \ fail_unless (ges_container_add (GES_CONTAINER (clip), \ GES_TIMELINE_ELEMENT (child))) #define _assert_remove(clip, child) \ fail_unless (ges_container_remove (GES_CONTAINER (clip), \ GES_TIMELINE_ELEMENT (child))) GST_START_TEST (test_object_properties) { GESClip *clip; GESTrack *track; GESTimeline *timeline; GESLayer *layer; GESTrackElement *trackelement; ges_init (); track = GES_TRACK (ges_video_track_new ()); fail_unless (track != NULL); layer = ges_layer_new (); fail_unless (layer != NULL); timeline = ges_timeline_new (); fail_unless (timeline != NULL); fail_unless (ges_timeline_add_layer (timeline, layer)); fail_unless (ges_timeline_add_track (timeline, track)); clip = (GESClip *) ges_test_clip_new (); fail_unless (clip != NULL); /* Set some properties */ g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 51, "in-point", (guint64) 12, NULL); assert_equals_uint64 (_START (clip), 42); assert_equals_uint64 (_DURATION (clip), 51); assert_equals_uint64 (_INPOINT (clip), 12); ges_layer_add_clip (layer, GES_CLIP (clip)); ges_timeline_commit (timeline); assert_num_children (clip, 1); trackelement = GES_CONTAINER_CHILDREN (clip)->data; fail_unless (trackelement != NULL); fail_unless (GES_TIMELINE_ELEMENT_PARENT (trackelement) == GES_TIMELINE_ELEMENT (clip)); fail_unless (ges_track_element_get_track (trackelement) == track); /* Check that trackelement has the same properties */ assert_equals_uint64 (_START (trackelement), 42); assert_equals_uint64 (_DURATION (trackelement), 51); assert_equals_uint64 (_INPOINT (trackelement), 12); /* And let's also check that it propagated correctly to GNonLin */ nle_object_check (ges_track_element_get_nleobject (trackelement), 42, 51, 12, 51, MIN_NLE_PRIO + TRANSITIONS_HEIGHT, TRUE); /* Change more properties, see if they propagate */ g_object_set (clip, "start", (guint64) 420, "duration", (guint64) 510, "in-point", (guint64) 120, NULL); assert_equals_uint64 (_START (clip), 420); assert_equals_uint64 (_DURATION (clip), 510); assert_equals_uint64 (_INPOINT (clip), 120); assert_equals_uint64 (_START (trackelement), 420); assert_equals_uint64 (_DURATION (trackelement), 510); assert_equals_uint64 (_INPOINT (trackelement), 120); /* And let's also check that it propagated correctly to GNonLin */ ges_timeline_commit (timeline); nle_object_check (ges_track_element_get_nleobject (trackelement), 420, 510, 120, 510, MIN_NLE_PRIO + TRANSITIONS_HEIGHT, TRUE); /* This time, we move the trackelement to see if the changes move * along to the parent and the gnonlin clip */ g_object_set (trackelement, "start", (guint64) 400, NULL); ges_timeline_commit (timeline); assert_equals_uint64 (_START (clip), 400); assert_equals_uint64 (_START (trackelement), 400); nle_object_check (ges_track_element_get_nleobject (trackelement), 400, 510, 120, 510, MIN_NLE_PRIO + TRANSITIONS_HEIGHT, TRUE); _assert_remove (clip, trackelement); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_split_direct_bindings) { GList *values; GstControlSource *source; GESTimeline *timeline; GESClip *clip, *splitclip; GstControlBinding *binding = NULL, *splitbinding; GstTimedValueControlSource *splitsource; GESLayer *layer; GESAsset *asset; GValue *tmpvalue; GESTrackElement *element; ges_init (); fail_unless ((timeline = ges_timeline_new ())); fail_unless ((layer = ges_layer_new ())); fail_unless (ges_timeline_add_track (timeline, GES_TRACK (ges_video_track_new ()))); fail_unless (ges_timeline_add_layer (timeline, layer)); asset = ges_asset_request (GES_TYPE_TEST_CLIP, NULL, NULL); clip = ges_layer_add_asset (layer, asset, 0, 10 * GST_SECOND, 10 * GST_SECOND, GES_TRACK_TYPE_UNKNOWN); g_object_unref (asset); CHECK_OBJECT_PROPS (clip, 0 * GST_SECOND, 10 * GST_SECOND, 10 * GST_SECOND); assert_num_children (clip, 1); check_layer (clip, 0); source = gst_interpolation_control_source_new (); g_object_set (source, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL); element = GES_CONTAINER_CHILDREN (clip)->data; fail_unless (ges_track_element_set_control_source (element, source, "alpha", "direct")); gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (source), 10 * GST_SECOND, 0.0); gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (source), 20 * GST_SECOND, 1.0); binding = ges_track_element_get_control_binding (element, "alpha"); tmpvalue = gst_control_binding_get_value (binding, 10 * GST_SECOND); assert_equals_int (g_value_get_double (tmpvalue), 0.0); g_value_unset (tmpvalue); g_free (tmpvalue); tmpvalue = gst_control_binding_get_value (binding, 20 * GST_SECOND); assert_equals_int (g_value_get_double (tmpvalue), 1.0); g_value_unset (tmpvalue); g_free (tmpvalue); splitclip = ges_clip_split (clip, 5 * GST_SECOND); CHECK_OBJECT_PROPS (splitclip, 5 * GST_SECOND, 15 * GST_SECOND, 5 * GST_SECOND); check_layer (splitclip, 0); splitbinding = ges_track_element_get_control_binding (GES_CONTAINER_CHILDREN (splitclip)->data, "alpha"); g_object_get (splitbinding, "control_source", &splitsource, NULL); values = gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE (splitsource)); assert_equals_int (g_list_length (values), 2); assert_equals_uint64 (((GstTimedValue *) values->data)->timestamp, 15 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->data)->value, 0.5); assert_equals_uint64 (((GstTimedValue *) values->next->data)->timestamp, 20 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->next->data)->value, 1.0); g_list_free (values); values = gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE (source)); assert_equals_int (g_list_length (values), 2); assert_equals_uint64 (((GstTimedValue *) values->data)->timestamp, 10 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->data)->value, 0.0); assert_equals_uint64 (((GstTimedValue *) values->next->data)->timestamp, 15 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->next->data)->value, 0.50); g_list_free (values); CHECK_OBJECT_PROPS (clip, 0 * GST_SECOND, 10 * GST_SECOND, 5 * GST_SECOND); check_layer (clip, 0); gst_object_unref (timeline); gst_object_unref (source); gst_object_unref (splitsource); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_split_direct_absolute_bindings) { GList *values; GstControlSource *source; GESTimeline *timeline; GESClip *clip, *splitclip; GstControlBinding *binding = NULL, *splitbinding; GstTimedValueControlSource *splitsource; GESLayer *layer; GESAsset *asset; GValue *tmpvalue; GESTrackElement *element; ges_init (); fail_unless ((timeline = ges_timeline_new ())); fail_unless ((layer = ges_layer_new ())); fail_unless (ges_timeline_add_track (timeline, GES_TRACK (ges_video_track_new ()))); fail_unless (ges_timeline_add_layer (timeline, layer)); asset = ges_asset_request (GES_TYPE_TEST_CLIP, NULL, NULL); clip = ges_layer_add_asset (layer, asset, 0, 10 * GST_SECOND, 10 * GST_SECOND, GES_TRACK_TYPE_UNKNOWN); g_object_unref (asset); CHECK_OBJECT_PROPS (clip, 0 * GST_SECOND, 10 * GST_SECOND, 10 * GST_SECOND); assert_num_children (clip, 1); check_layer (clip, 0); source = gst_interpolation_control_source_new (); g_object_set (source, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL); element = GES_CONTAINER_CHILDREN (clip)->data; fail_unless (ges_track_element_set_control_source (element, source, "posx", "direct-absolute")); gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (source), 10 * GST_SECOND, 0); gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (source), 20 * GST_SECOND, 500); binding = ges_track_element_get_control_binding (element, "posx"); tmpvalue = gst_control_binding_get_value (binding, 10 * GST_SECOND); assert_equals_int (g_value_get_int (tmpvalue), 0); g_value_unset (tmpvalue); g_free (tmpvalue); tmpvalue = gst_control_binding_get_value (binding, 20 * GST_SECOND); assert_equals_int (g_value_get_int (tmpvalue), 500); g_value_unset (tmpvalue); g_free (tmpvalue); splitclip = ges_clip_split (clip, 5 * GST_SECOND); CHECK_OBJECT_PROPS (splitclip, 5 * GST_SECOND, 15 * GST_SECOND, 5 * GST_SECOND); check_layer (splitclip, 0); splitbinding = ges_track_element_get_control_binding (GES_CONTAINER_CHILDREN (splitclip)->data, "posx"); g_object_get (splitbinding, "control_source", &splitsource, NULL); values = gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE (splitsource)); assert_equals_int (g_list_length (values), 2); assert_equals_uint64 (((GstTimedValue *) values->data)->timestamp, 15 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->data)->value, 250.0); assert_equals_uint64 (((GstTimedValue *) values->next->data)->timestamp, 20 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->next->data)->value, 500.0); g_list_free (values); values = gst_timed_value_control_source_get_all (GST_TIMED_VALUE_CONTROL_SOURCE (source)); assert_equals_int (g_list_length (values), 2); assert_equals_uint64 (((GstTimedValue *) values->data)->timestamp, 10 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->data)->value, 0.0); assert_equals_uint64 (((GstTimedValue *) values->next->data)->timestamp, 15 * GST_SECOND); assert_equals_float (((GstTimedValue *) values->next->data)->value, 250.0); g_list_free (values); CHECK_OBJECT_PROPS (clip, 0 * GST_SECOND, 10 * GST_SECOND, 5 * GST_SECOND); check_layer (clip, 0); gst_object_unref (timeline); gst_object_unref (source); gst_object_unref (splitsource); ges_deinit (); } GST_END_TEST; static GESTimelineElement * _find_auto_transition (GESTrack * track, GESClip * from_clip, GESClip * to_clip) { GstClockTime start, end; GList *tmp, *track_els; GESTimelineElement *ret = NULL; GESLayer *layer0, *layer1; layer0 = ges_clip_get_layer (from_clip); layer1 = ges_clip_get_layer (to_clip); fail_unless (layer0 == layer1, "%" GES_FORMAT " and %" GES_FORMAT " do not " "share the same layer", GES_ARGS (from_clip), GES_ARGS (to_clip)); gst_object_unref (layer1); start = GES_TIMELINE_ELEMENT_START (to_clip); end = GES_TIMELINE_ELEMENT_START (from_clip) + GES_TIMELINE_ELEMENT_DURATION (from_clip); fail_if (end <= start, "%" GES_FORMAT " starts after %" GES_FORMAT " ends", GES_ARGS (to_clip), GES_ARGS (from_clip)); track_els = ges_track_get_elements (track); for (tmp = track_els; tmp; tmp = tmp->next) { GESTimelineElement *el = tmp->data; if (GES_IS_TRANSITION (el) && el->start == start && (el->start + el->duration) == end) { fail_if (ret, "Found two transitions %" GES_FORMAT " and %" GES_FORMAT " between %" GES_FORMAT " and %" GES_FORMAT " in track %" GST_PTR_FORMAT, GES_ARGS (el), GES_ARGS (ret), GES_ARGS (from_clip), GES_ARGS (to_clip), track); ret = el; } } fail_unless (ret, "Found no transitions between %" GES_FORMAT " and %" GES_FORMAT " in track %" GST_PTR_FORMAT, GES_ARGS (from_clip), GES_ARGS (to_clip), track); g_list_free_full (track_els, gst_object_unref); fail_unless (GES_IS_CLIP (ret->parent), "Transition %" GES_FORMAT " between %" GES_FORMAT " and %" GES_FORMAT " in track %" GST_PTR_FORMAT " has no parent clip", GES_ARGS (ret), GES_ARGS (from_clip), GES_ARGS (to_clip), track); layer1 = ges_clip_get_layer (GES_CLIP (ret->parent)); fail_unless (layer0 == layer1, "Transition %" GES_FORMAT " between %" GES_FORMAT " and %" GES_FORMAT " in track %" GST_PTR_FORMAT " belongs to layer %" GST_PTR_FORMAT " rather than %" GST_PTR_FORMAT, GES_ARGS (ret), GES_ARGS (from_clip), GES_ARGS (to_clip), track, layer1, layer0); gst_object_unref (layer0); gst_object_unref (layer1); return ret; } GST_START_TEST (test_split_with_auto_transitions) { GESTimeline *timeline; GESLayer *layer; GESTrack *tracks[3]; GESTimelineElement *found; GESTimelineElement *prev_trans[3]; GESTimelineElement *post_trans[3]; GESAsset *asset; GESClip *clip, *split, *prev, *post; guint i; ges_init (); timeline = ges_timeline_new (); ges_timeline_set_auto_transition (timeline, TRUE); tracks[0] = GES_TRACK (ges_audio_track_new ()); tracks[1] = GES_TRACK (ges_audio_track_new ()); tracks[2] = GES_TRACK (ges_video_track_new ()); for (i = 0; i < 3; i++) fail_unless (ges_timeline_add_track (timeline, tracks[i])); layer = ges_timeline_append_layer (timeline); asset = ges_asset_request (GES_TYPE_TEST_CLIP, NULL, NULL); prev = ges_layer_add_asset (layer, asset, 0, 0, 10, GES_TRACK_TYPE_UNKNOWN); clip = ges_layer_add_asset (layer, asset, 5, 0, 20, GES_TRACK_TYPE_UNKNOWN); post = ges_layer_add_asset (layer, asset, 20, 0, 10, GES_TRACK_TYPE_UNKNOWN); fail_unless (prev); fail_unless (clip); fail_unless (post); for (i = 0; i < 3; i++) { prev_trans[i] = _find_auto_transition (tracks[i], prev, clip); post_trans[i] = _find_auto_transition (tracks[i], clip, post); /* 3 sources, 2 auto-transitions */ assert_num_in_track (tracks[i], 5); } /* cannot split within a transition */ fail_if (ges_clip_split (clip, 5)); fail_if (ges_clip_split (clip, 20)); /* we should keep the same auto-transitions during a split */ split = ges_clip_split (clip, 15); fail_unless (split); for (i = 0; i < 3; i++) { found = _find_auto_transition (tracks[i], prev, clip); fail_unless (found == prev_trans[i], "Transition between %" GES_FORMAT " and %" GES_FORMAT " changed", GES_ARGS (prev), GES_ARGS (clip)); found = _find_auto_transition (tracks[i], split, post); fail_unless (found == post_trans[i], "Transition between %" GES_FORMAT " and %" GES_FORMAT " changed", GES_ARGS (clip), GES_ARGS (post)); } gst_object_unref (timeline); gst_object_unref (asset); ges_deinit (); } GST_END_TEST; static GPtrArray * _select_none (GESTimeline * timeline, GESClip * clip, GESTrackElement * track_element, guint * called_p) { (*called_p)++; return NULL; } static GPtrArray * _select_track (GESTimeline * timeline, GESClip * clip, GESTrackElement * track_element, GESTrack ** track_p) { GPtrArray *tracks = g_ptr_array_new (); fail_unless (track_p); fail_unless (*track_p); g_ptr_array_insert (tracks, -1, gst_object_ref (*track_p)); *track_p = NULL; return tracks; } GST_START_TEST (test_split_object) { GESTimeline *timeline; GESTrack *track1, *track2, *effect_track; GESLayer *layer; GESClip *clip, *splitclip; GList *splittrackelements; GESTrackElement *trackelement1, *trackelement2, *effect1, *effect2, *splittrackelement; guint32 priority1, priority2, effect_priority1, effect_priority2; guint selection_called = 0; const gchar *meta; ges_init (); layer = ges_layer_new (); fail_unless (layer != NULL); timeline = ges_timeline_new_audio_video (); fail_unless (timeline != NULL); fail_unless (ges_timeline_add_layer (timeline, layer)); ASSERT_OBJECT_REFCOUNT (timeline, "timeline", 1); clip = GES_CLIP (ges_test_clip_new ()); fail_unless (clip != NULL); ASSERT_OBJECT_REFCOUNT (timeline, "timeline", 1); /* Set some properties */ g_object_set (clip, "start", (guint64) 42, "duration", (guint64) 50, "in-point", (guint64) 12, NULL); ASSERT_OBJECT_REFCOUNT (timeline, "timeline", 1); CHECK_OBJECT_PROPS (clip, 42, 12, 50); ges_layer_add_clip (layer, GES_CLIP (clip)); ges_timeline_commit (timeline); assert_num_children (clip, 2); trackelement1 = GES_CONTAINER_CHILDREN (clip)->data; fail_unless (trackelement1 != NULL); fail_unless (GES_TIMELINE_ELEMENT_PARENT (trackelement1) == GES_TIMELINE_ELEMENT (clip)); ges_meta_container_set_string (GES_META_CONTAINER (trackelement1), "test_key", "test_value"); trackelement2 = GES_CONTAINER_CHILDREN (clip)->next->data; fail_unless (trackelement2 != NULL); fail_unless (GES_TIMELINE_ELEMENT_PARENT (trackelement2) == GES_TIMELINE_ELEMENT (clip)); effect1 = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); _assert_add (clip, effect1); effect2 = GES_TRACK_ELEMENT (ges_effect_new ("vertigotv")); _assert_add (clip, effect2); /* Check that trackelement has the same properties */ CHECK_OBJECT_PROPS (trackelement1, 42, 12, 50); CHECK_OBJECT_PROPS (trackelement2, 42, 12, 50); CHECK_OBJECT_PROPS (effect1, 42, 0, 50); CHECK_OBJECT_PROPS (effect2, 42, 0, 50); /* And let's also check that it propagated correctly to GNonLin */ nle_object_check (ges_track_element_get_nleobject (trackelement1), 42, 50, 12, 50, MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, TRUE); nle_object_check (ges_track_element_get_nleobject (trackelement2), 42, 50, 12, 50, MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, TRUE); track1 = ges_track_element_get_track (trackelement1); fail_unless (track1); track2 = ges_track_element_get_track (trackelement2); fail_unless (track2); fail_unless (track1 != track2); effect_track = ges_track_element_get_track (effect1); fail_unless (effect_track); fail_unless (ges_track_element_get_track (effect2) == effect_track); priority1 = GES_TIMELINE_ELEMENT_PRIORITY (trackelement1); priority2 = GES_TIMELINE_ELEMENT_PRIORITY (trackelement2); effect_priority1 = GES_TIMELINE_ELEMENT_PRIORITY (effect1); effect_priority2 = GES_TIMELINE_ELEMENT_PRIORITY (effect2); fail_unless (priority1 == priority2); fail_unless (priority1 > effect_priority2); fail_unless (effect_priority2 > effect_priority1); ges_timeline_element_set_child_properties (GES_TIMELINE_ELEMENT (clip), "font-desc", "Normal", "posx", 30, "posy", 50, "alpha", 0.1, "freq", 449.0, "scratch-lines", 2, "zoom-speed", 1.05, NULL); /* splitting should avoid track selection */ g_signal_connect (timeline, "select-tracks-for-object", G_CALLBACK (_select_none), &selection_called); splitclip = ges_clip_split (clip, 67); fail_unless (GES_IS_CLIP (splitclip)); fail_unless (splitclip != clip); fail_if (selection_called); CHECK_OBJECT_PROPS (clip, 42, 12, 25); CHECK_OBJECT_PROPS (trackelement1, 42, 12, 25); CHECK_OBJECT_PROPS (trackelement1, 42, 12, 25); CHECK_OBJECT_PROPS (effect1, 42, 0, 25); CHECK_OBJECT_PROPS (effect2, 42, 0, 25); CHECK_OBJECT_PROPS (splitclip, 67, 37, 25); assert_equal_children_properties (splitclip, clip); splittrackelements = GES_CONTAINER_CHILDREN (splitclip); fail_unless_equals_int (g_list_length (splittrackelements), 4); /* first is the effects */ splittrackelement = GES_TRACK_ELEMENT (splittrackelements->data); fail_unless (GES_IS_TRACK_ELEMENT (splittrackelement)); CHECK_OBJECT_PROPS (splittrackelement, 67, 0, 25); assert_equal_children_properties (splittrackelement, effect1); fail_unless (ges_track_element_get_track (splittrackelement) == effect_track); fail_unless (ges_track_element_get_track (effect1) == effect_track); /* +3 priority from layer */ assert_equals_int (GES_TIMELINE_ELEMENT_PRIORITY (splittrackelement), effect_priority1 + 3); fail_unless (GES_TIMELINE_ELEMENT_PRIORITY (effect1) == effect_priority1); fail_unless (splittrackelement != trackelement1); fail_unless (splittrackelement != trackelement2); fail_unless (splittrackelement != effect1); fail_unless (splittrackelement != effect2); splittrackelement = GES_TRACK_ELEMENT (splittrackelements->next->data); fail_unless (GES_IS_TRACK_ELEMENT (splittrackelement)); CHECK_OBJECT_PROPS (splittrackelement, 67, 0, 25); assert_equal_children_properties (splittrackelement, effect2); fail_unless (ges_track_element_get_track (splittrackelement) == effect_track); fail_unless (ges_track_element_get_track (effect2) == effect_track); assert_equals_int (GES_TIMELINE_ELEMENT_PRIORITY (splittrackelement), effect_priority2 + 3); fail_unless (GES_TIMELINE_ELEMENT_PRIORITY (effect2) == effect_priority2); fail_unless (splittrackelement != trackelement1); fail_unless (splittrackelement != trackelement2); fail_unless (splittrackelement != effect1); fail_unless (splittrackelement != effect2); splittrackelement = GES_TRACK_ELEMENT (splittrackelements->next->next->data); fail_unless (GES_IS_TRACK_ELEMENT (splittrackelement)); CHECK_OBJECT_PROPS (splittrackelement, 67, 37, 25); /* core elements have swapped order in the clip, this is ok since they * share the same priority */ assert_equal_children_properties (splittrackelement, trackelement2); fail_unless (ges_track_element_get_track (splittrackelement) == track2); fail_unless (ges_track_element_get_track (trackelement2) == track2); assert_equals_int (GES_TIMELINE_ELEMENT_PRIORITY (splittrackelement), priority2 + 3); fail_unless (GES_TIMELINE_ELEMENT_PRIORITY (trackelement2) == priority2); fail_unless (splittrackelement != trackelement1); fail_unless (splittrackelement != trackelement2); fail_unless (splittrackelement != effect1); fail_unless (splittrackelement != effect2); splittrackelement = GES_TRACK_ELEMENT (splittrackelements->next->next->next->data); fail_unless (GES_IS_TRACK_ELEMENT (splittrackelement)); CHECK_OBJECT_PROPS (splittrackelement, 67, 37, 25); assert_equal_children_properties (splittrackelement, trackelement1); fail_unless (ges_track_element_get_track (splittrackelement) == track1); fail_unless (ges_track_element_get_track (trackelement1) == track1); assert_equals_int (GES_TIMELINE_ELEMENT_PRIORITY (splittrackelement), priority1 + 3); fail_unless (GES_TIMELINE_ELEMENT_PRIORITY (trackelement1) == priority2); meta = ges_meta_container_get_string (GES_META_CONTAINER (splittrackelement), "test_key"); fail_unless_equals_string (meta, "test_value"); fail_unless (splittrackelement != trackelement1); fail_unless (splittrackelement != trackelement2); fail_unless (splittrackelement != effect1); fail_unless (splittrackelement != effect2); /* We own the only ref */ ASSERT_OBJECT_REFCOUNT (splitclip, "1 ref for us + 1 for the timeline", 2); /* 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*/ ASSERT_OBJECT_REFCOUNT (splittrackelement, "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, splittrackelement, NULL); ges_deinit (); } GST_END_TEST; typedef struct { gboolean duration_cb_called; gboolean clip_added_cb_called; gboolean track_selected_cb_called; GESClip *clip; } SplitOrderData; static void _track_selected_cb (GESTimelineElement * el, GParamSpec * spec, SplitOrderData * data) { GESClip *clip = GES_CLIP (el->parent); fail_unless (data->clip == clip, "Parent is %" GES_FORMAT " rather than %" GES_FORMAT, GES_ARGS (clip), GES_ARGS (data->clip)); fail_unless (data->duration_cb_called, "notify::duration not emitted " "for neighbour of %" GES_FORMAT, GES_ARGS (data->clip)); fail_unless (data->clip_added_cb_called, "child-added not emitted for %" GES_FORMAT, GES_ARGS (data->clip)); data->track_selected_cb_called = TRUE; } static void _child_added_cb (GESClip * clip, GESTimelineElement * child, SplitOrderData * data) { fail_unless (data->clip == clip, "Received %" GES_FORMAT " rather than %" GES_FORMAT, GES_ARGS (clip), GES_ARGS (data->clip)); g_signal_connect (child, "notify::track", G_CALLBACK (_track_selected_cb), data); } static void _clip_added_cb (GESLayer * layer, GESClip * clip, SplitOrderData * data) { GList *tmp; data->clip = clip; fail_unless (data->duration_cb_called, "notify::duration not emitted " "for neighbour of %" GES_FORMAT, GES_ARGS (data->clip)); /* only called once */ fail_if (data->clip_added_cb_called, "clip-added already emitted for %" GES_FORMAT, GES_ARGS (data->clip)); fail_if (data->track_selected_cb_called, "track selection already " "occurred for %" GES_FORMAT, GES_ARGS (data->clip)); data->clip_added_cb_called = TRUE; g_signal_connect (clip, "child-added", G_CALLBACK (_child_added_cb), data); for (tmp = GES_CONTAINER_CHILDREN (clip); tmp; tmp = tmp->next) g_signal_connect (tmp->data, "notify::track", G_CALLBACK (_track_selected_cb), data); } static void _disconnect_cbs (GESLayer * layer, GESClip * clip, SplitOrderData * data) { GList *tmp; g_signal_handlers_disconnect_by_func (clip, _child_added_cb, data); for (tmp = GES_CONTAINER_CHILDREN (clip); tmp; tmp = tmp->next) g_signal_handlers_disconnect_by_func (tmp->data, _track_selected_cb, data); } static void _duration_cb (GObject * object, GParamSpec * pspec, SplitOrderData * data) { /* only called once */ fail_if (data->duration_cb_called, "notify::duration of neighbour %" GES_FORMAT " already emitted ", GES_ARGS (object)); fail_if (data->clip_added_cb_called, "clip-added already emitted"); fail_if (data->track_selected_cb_called, "track selection already " "occurred"); data->duration_cb_called = TRUE; } GST_START_TEST (test_split_ordering) { GESTimeline *timeline; GESLayer *layer; GESClip *clip, *splitclip; SplitOrderData data; ges_init (); timeline = ges_timeline_new_audio_video (); layer = ges_timeline_append_layer (timeline); clip = GES_CLIP (ges_test_clip_new ()); assert_set_duration (clip, 10); /* test order when adding clip to a layer */ /* don't care about duration yet */ data.duration_cb_called = TRUE; data.clip_added_cb_called = FALSE; data.track_selected_cb_called = FALSE; data.clip = NULL; g_signal_connect (layer, "clip-added", G_CALLBACK (_clip_added_cb), &data); fail_unless (ges_layer_add_clip (layer, clip)); fail_unless (data.duration_cb_called); fail_unless (data.clip_added_cb_called); fail_unless (data.track_selected_cb_called); fail_unless (data.clip == clip); /* now check for the same ordering when splitting, which the original * clip shrinking before the new one is added to the layer */ data.duration_cb_called = FALSE; data.clip_added_cb_called = FALSE; data.track_selected_cb_called = FALSE; data.clip = NULL; g_signal_connect (clip, "notify::duration", G_CALLBACK (_duration_cb), &data); splitclip = ges_clip_split (clip, 5); fail_unless (splitclip); fail_unless (data.duration_cb_called); fail_unless (data.clip_added_cb_called); fail_unless (data.track_selected_cb_called); fail_unless (data.clip == splitclip); /* disconnect since track of children will change when timeline is * freed */ _disconnect_cbs (layer, clip, &data); _disconnect_cbs (layer, splitclip, &data); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; #define _assert_higher_priority(el, higher) \ { \ if (higher) { \ guint32 el_prio = GES_TIMELINE_ELEMENT_PRIORITY (el); \ guint32 higher_prio = GES_TIMELINE_ELEMENT_PRIORITY (higher); \ fail_unless (el_prio > higher_prio, "%s does not have a higher " \ "priority than %s (%u vs %u)", GES_TIMELINE_ELEMENT_NAME (el), \ GES_TIMELINE_ELEMENT_NAME (higher), el_prio, higher_prio); \ } \ } #define _assert_regroup_fails(clip_list) \ { \ GESContainer *regrouped = ges_container_group (clip_list); \ fail_unless (GES_IS_GROUP (regrouped)); \ assert_equals_int (g_list_length (regrouped->children), \ g_list_length (clip_list)); \ g_list_free_full (ges_container_ungroup (regrouped, FALSE), \ gst_object_unref); \ } GST_START_TEST (test_clip_group_ungroup) { GESAsset *asset; GESTimeline *timeline; GESClip *clip, *video_clip, *audio_clip; GESTrackElement *el; GList *containers, *tmp; GESLayer *layer; GESContainer *regrouped_clip; GESTrack *audio_track, *video_track; guint selection_called = 0; struct { GESTrackElement *element; GESTrackElement *higher_priority; } audio_els[2]; struct { GESTrackElement *element; GESTrackElement *higher_priority; } video_els[3]; guint i, j; const gchar *name; GESTrackType type; ges_init (); timeline = ges_timeline_new (); layer = ges_layer_new (); audio_track = GES_TRACK (ges_audio_track_new ()); video_track = GES_TRACK (ges_video_track_new ()); fail_unless (ges_timeline_add_track (timeline, audio_track)); fail_unless (ges_timeline_add_track (timeline, video_track)); fail_unless (ges_timeline_add_layer (timeline, layer)); asset = ges_asset_request (GES_TYPE_TEST_CLIP, NULL, NULL); assert_is_type (asset, GES_TYPE_ASSET); clip = ges_layer_add_asset (layer, asset, 0, 0, 10, GES_TRACK_TYPE_UNKNOWN); ASSERT_OBJECT_REFCOUNT (clip, "1 layer + 1 timeline.all_els", 2); assert_num_children (clip, 2); CHECK_OBJECT_PROPS (clip, 0, 0, 10); el = GES_TRACK_ELEMENT (ges_effect_new ("audioecho")); ges_track_element_set_track_type (el, GES_TRACK_TYPE_AUDIO); _assert_add (clip, el); el = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); ges_track_element_set_track_type (el, GES_TRACK_TYPE_VIDEO); _assert_add (clip, el); el = GES_TRACK_ELEMENT (ges_effect_new ("videobalance")); ges_track_element_set_track_type (el, GES_TRACK_TYPE_VIDEO); _assert_add (clip, el); assert_num_children (clip, 5); CHECK_OBJECT_PROPS (clip, 0, 0, 10); i = j = 0; for (tmp = GES_CONTAINER_CHILDREN (clip); tmp; tmp = tmp->next) { el = tmp->data; type = ges_track_element_get_track_type (el); if (type == GES_TRACK_TYPE_AUDIO) { fail_unless (i < G_N_ELEMENTS (audio_els)); audio_els[i].element = el; fail_unless (ges_track_element_get_track (el) == audio_track, "%s not in audio track", GES_TIMELINE_ELEMENT_NAME (el)); if (i == 0) audio_els[i].higher_priority = NULL; else audio_els[i].higher_priority = audio_els[i - 1].element; _assert_higher_priority (el, audio_els[i].higher_priority); i++; } if (type == GES_TRACK_TYPE_VIDEO) { fail_unless (j < G_N_ELEMENTS (video_els)); video_els[j].element = el; fail_unless (ges_track_element_get_track (el) == video_track, "%s not in video track", GES_TIMELINE_ELEMENT_NAME (el)); if (j == 0) video_els[j].higher_priority = NULL; else video_els[j].higher_priority = video_els[j - 1].element; _assert_higher_priority (el, video_els[j].higher_priority); j++; } } fail_unless (i == G_N_ELEMENTS (audio_els)); fail_unless (j == G_N_ELEMENTS (video_els)); assert_num_in_track (audio_track, 2); assert_num_in_track (video_track, 3); /* group and ungroup should avoid track selection */ g_signal_connect (timeline, "select-tracks-for-object", G_CALLBACK (_select_none), &selection_called); containers = ges_container_ungroup (GES_CONTAINER (clip), FALSE); fail_if (selection_called); video_clip = NULL; audio_clip = NULL; assert_equals_int (g_list_length (containers), 2); type = ges_clip_get_supported_formats (containers->data); if (type == GES_TRACK_TYPE_VIDEO) video_clip = containers->data; if (type == GES_TRACK_TYPE_AUDIO) audio_clip = containers->data; type = ges_clip_get_supported_formats (containers->next->data); if (type == GES_TRACK_TYPE_VIDEO) video_clip = containers->next->data; if (type == GES_TRACK_TYPE_AUDIO) audio_clip = containers->next->data; fail_unless (video_clip); fail_unless (audio_clip); fail_unless (video_clip == clip || audio_clip == clip); assert_layer (video_clip, layer); assert_num_children (video_clip, 3); fail_unless (GES_TIMELINE_ELEMENT_TIMELINE (video_clip) == timeline); CHECK_OBJECT_PROPS (video_clip, 0, 0, 10); ASSERT_OBJECT_REFCOUNT (video_clip, "1 for the layer + 1 for the timeline + " "1 in containers list", 3); assert_layer (audio_clip, layer); assert_num_children (audio_clip, 2); fail_unless (GES_TIMELINE_ELEMENT_TIMELINE (audio_clip) == timeline); CHECK_OBJECT_PROPS (audio_clip, 0, 0, 10); ASSERT_OBJECT_REFCOUNT (audio_clip, "1 for the layer + 1 for the timeline + " "1 in containers list", 3); for (i = 0; i < G_N_ELEMENTS (audio_els); i++) { el = audio_els[i].element; name = GES_TIMELINE_ELEMENT_NAME (el); fail_unless (ges_track_element_get_track (el) == audio_track, "%s not in audio track", name); fail_unless (GES_TIMELINE_ELEMENT_PARENT (el) == GES_TIMELINE_ELEMENT (audio_clip), "%s not in the audio clip", name); ASSERT_OBJECT_REFCOUNT (el, "1 for the track + 1 for the container " "+ 1 for the timeline", 3); _assert_higher_priority (el, audio_els[i].higher_priority); } for (i = 0; i < G_N_ELEMENTS (video_els); i++) { el = video_els[i].element; name = GES_TIMELINE_ELEMENT_NAME (el); fail_unless (ges_track_element_get_track (el) == video_track, "%s not in video track", name); fail_unless (GES_TIMELINE_ELEMENT_PARENT (el) == GES_TIMELINE_ELEMENT (video_clip), "%s not in the video clip", name); ASSERT_OBJECT_REFCOUNT (el, "1 for the track + 1 for the container " "+ 1 for the timeline", 3); _assert_higher_priority (el, video_els[i].higher_priority); } assert_num_in_track (audio_track, 2); assert_num_in_track (video_track, 3); assert_set_start (video_clip, 10); CHECK_OBJECT_PROPS (video_clip, 10, 0, 10); CHECK_OBJECT_PROPS (audio_clip, 0, 0, 10); _assert_regroup_fails (containers); assert_set_start (video_clip, 0); assert_set_inpoint (video_clip, 10); CHECK_OBJECT_PROPS (video_clip, 0, 10, 10); CHECK_OBJECT_PROPS (audio_clip, 0, 0, 10); _assert_regroup_fails (containers); assert_set_inpoint (video_clip, 0); assert_set_duration (video_clip, 15); CHECK_OBJECT_PROPS (video_clip, 0, 0, 15); CHECK_OBJECT_PROPS (audio_clip, 0, 0, 10); _assert_regroup_fails (containers); assert_set_duration (video_clip, 10); CHECK_OBJECT_PROPS (video_clip, 0, 0, 10); CHECK_OBJECT_PROPS (audio_clip, 0, 0, 10); regrouped_clip = ges_container_group (containers); fail_if (selection_called); assert_is_type (regrouped_clip, GES_TYPE_CLIP); assert_num_children (regrouped_clip, 5); assert_equals_int (ges_clip_get_supported_formats (GES_CLIP (regrouped_clip)), GES_TRACK_TYPE_VIDEO | GES_TRACK_TYPE_AUDIO); g_list_free_full (containers, gst_object_unref); assert_layer (regrouped_clip, layer); for (i = 0; i < G_N_ELEMENTS (audio_els); i++) { el = audio_els[i].element; name = GES_TIMELINE_ELEMENT_NAME (el); fail_unless (ges_track_element_get_track (el) == audio_track, "%s not in audio track", name); fail_unless (GES_TIMELINE_ELEMENT_PARENT (el) == GES_TIMELINE_ELEMENT (regrouped_clip), "%s not in the regrouped clip", name); ASSERT_OBJECT_REFCOUNT (el, "1 for the track + 1 for the container " "+ 1 for the timeline", 3); _assert_higher_priority (el, audio_els[i].higher_priority); } for (i = 0; i < G_N_ELEMENTS (video_els); i++) { el = video_els[i].element; name = GES_TIMELINE_ELEMENT_NAME (el); fail_unless (ges_track_element_get_track (el) == video_track, "%s not in video track", name); fail_unless (GES_TIMELINE_ELEMENT_PARENT (el) == GES_TIMELINE_ELEMENT (regrouped_clip), "%s not in the regrouped clip", name); ASSERT_OBJECT_REFCOUNT (el, "1 for the track + 1 for the container " "+ 1 for the timeline", 3); _assert_higher_priority (el, video_els[i].higher_priority); } assert_num_in_track (audio_track, 2); assert_num_in_track (video_track, 3); gst_object_unref (timeline); gst_object_unref (asset); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_clip_can_group) { GESTimeline *timeline; GESLayer *layer1, *layer2; GESTrack *track1, *track2, *track3, *select_track; GESAsset *asset1, *asset2, *asset3; GESContainer *container; GESClip *clip1, *clip2, *clip3, *grouped; GList *clips = NULL; ges_init (); timeline = ges_timeline_new (); track1 = GES_TRACK (ges_audio_track_new ()); track2 = GES_TRACK (ges_video_track_new ()); track3 = GES_TRACK (ges_video_track_new ()); fail_unless (ges_timeline_add_track (timeline, track1)); fail_unless (ges_timeline_add_track (timeline, track2)); layer1 = ges_timeline_append_layer (timeline); layer2 = ges_timeline_append_layer (timeline); asset1 = ges_asset_request (GES_TYPE_TEST_CLIP, NULL, NULL); asset2 = ges_asset_request (GES_TYPE_TEST_CLIP, "width=700", NULL); asset3 = ges_asset_request (GES_TYPE_EFFECT_CLIP, "audioecho || agingtv", NULL); /* fail if different layer */ clip1 = ges_layer_add_asset (layer1, asset1, 0, 0, 10, GES_TRACK_TYPE_VIDEO); fail_unless (clip1); assert_num_children (clip1, 1); assert_num_in_track (track1, 0); assert_num_in_track (track2, 1); clip2 = ges_layer_add_asset (layer2, asset1, 0, 0, 10, GES_TRACK_TYPE_AUDIO); fail_unless (clip2); assert_num_children (clip2, 1); assert_num_in_track (track1, 1); assert_num_in_track (track2, 1); clips = g_list_append (clips, clip1); clips = g_list_append (clips, clip2); _assert_regroup_fails (clips); g_list_free (clips); clips = NULL; gst_object_ref (clip1); gst_object_ref (clip2); fail_unless (ges_layer_remove_clip (layer1, clip1)); fail_unless (ges_layer_remove_clip (layer2, clip2)); assert_num_children (clip1, 1); assert_num_children (clip2, 1); gst_object_unref (clip1); gst_object_unref (clip2); assert_num_in_track (track1, 0); assert_num_in_track (track2, 0); /* fail if different asset */ clip1 = ges_layer_add_asset (layer1, asset1, 0, 0, 10, GES_TRACK_TYPE_VIDEO); fail_unless (clip1); assert_num_children (clip1, 1); clip2 = ges_layer_add_asset (layer1, asset2, 0, 0, 10, GES_TRACK_TYPE_AUDIO); fail_unless (clip2); assert_num_children (clip2, 1); assert_num_in_track (track1, 1); assert_num_in_track (track2, 1); clips = g_list_append (clips, clip1); clips = g_list_append (clips, clip2); _assert_regroup_fails (clips); g_list_free (clips); clips = NULL; fail_unless (ges_layer_remove_clip (layer1, clip1)); fail_unless (ges_layer_remove_clip (layer1, clip2)); /* fail if sharing track */ clip1 = ges_layer_add_asset (layer1, asset3, 0, 0, 10, GES_TRACK_TYPE_VIDEO); fail_unless (clip1); assert_num_children (clip1, 1); clip2 = ges_layer_add_asset (layer1, asset3, 0, 0, 10, GES_TRACK_TYPE_VIDEO); fail_unless (clip2); assert_num_children (clip2, 1); assert_num_in_track (track1, 0); assert_num_in_track (track2, 2); clips = g_list_append (clips, clip1); clips = g_list_append (clips, clip2); _assert_regroup_fails (clips); g_list_free (clips); clips = NULL; fail_unless (ges_layer_remove_clip (layer1, clip1)); fail_unless (ges_layer_remove_clip (layer1, clip2)); clip1 = ges_layer_add_asset (layer1, asset1, 0, 0, 10, GES_TRACK_TYPE_VIDEO); fail_unless (clip1); assert_num_children (clip1, 1); assert_num_in_track (track1, 0); assert_num_in_track (track2, 1); clip2 = ges_layer_add_asset (layer1, asset2, 0, 0, 10, GES_TRACK_TYPE_AUDIO); fail_unless (clip2); assert_num_children (clip2, 1); assert_num_in_track (track1, 1); assert_num_in_track (track2, 1); clips = g_list_append (clips, clip1); clips = g_list_append (clips, clip2); _assert_regroup_fails (clips); g_list_free (clips); clips = NULL; fail_unless (ges_layer_remove_clip (layer1, clip1)); fail_unless (ges_layer_remove_clip (layer1, clip2)); /* can group if same asset but different tracks */ clip1 = ges_layer_add_asset (layer1, asset2, 0, 0, 10, GES_TRACK_TYPE_VIDEO); fail_unless (clip1); _assert_add (clip1, ges_effect_new ("agingtv")); assert_num_children (clip1, 2); clip2 = ges_layer_add_asset (layer1, asset2, 0, 0, 10, GES_TRACK_TYPE_AUDIO); fail_unless (clip2); assert_num_children (clip2, 1); fail_unless (ges_timeline_add_track (timeline, track3)); assert_num_children (clip1, 2); assert_num_children (clip2, 1); assert_num_in_track (track1, 1); assert_num_in_track (track2, 2); assert_num_in_track (track3, 0); select_track = track3; g_signal_connect (timeline, "select-tracks-for-object", G_CALLBACK (_select_track), &select_track); clip3 = ges_layer_add_asset (layer1, asset2, 0, 0, 10, GES_TRACK_TYPE_VIDEO); fail_unless (select_track == NULL); assert_num_children (clip1, 2); assert_num_children (clip2, 1); assert_num_children (clip3, 1); assert_num_in_track (track1, 1); assert_num_in_track (track2, 2); assert_num_in_track (track3, 1); clips = g_list_append (clips, clip1); clips = g_list_append (clips, clip2); clips = g_list_append (clips, clip3); container = ges_container_group (clips); fail_unless (GES_IS_CLIP (container)); grouped = GES_CLIP (container); assert_num_children (grouped, 4); assert_num_in_track (track1, 1); assert_num_in_track (track2, 2); assert_num_in_track (track3, 1); fail_unless (ges_clip_get_supported_formats (grouped), GES_TRACK_TYPE_VIDEO | GES_TRACK_TYPE_AUDIO); fail_unless (ges_extractable_get_asset (GES_EXTRACTABLE (grouped)) == asset2); CHECK_OBJECT_PROPS (grouped, 0, 0, 10); g_list_free (clips); clips = ges_layer_get_clips (layer1); fail_unless (g_list_length (clips), 1); fail_unless (GES_CLIP (clips->data) == grouped); g_list_free_full (clips, gst_object_unref); gst_object_unref (asset1); gst_object_unref (asset2); gst_object_unref (asset3); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_adding_children_to_track) { GESTimeline *timeline; GESLayer *layer; GESTrack *track1, *track2; GESClip *clip, *clip2; GESAsset *asset; GESTrackElement *source, *effect, *effect2, *added, *added2, *added3; GstControlSource *ctrl_source; guint selection_called = 0; GError *error = NULL; ges_init (); timeline = ges_timeline_new (); ges_timeline_set_auto_transition (timeline, TRUE); track1 = GES_TRACK (ges_video_track_new ()); track2 = GES_TRACK (ges_video_track_new ()); /* only add two for now */ fail_unless (ges_timeline_add_track (timeline, track1)); layer = ges_timeline_append_layer (timeline); asset = ges_asset_request (GES_TYPE_TEST_CLIP, NULL, NULL); clip = ges_layer_add_asset (layer, asset, 0, 0, 10, GES_TRACK_TYPE_UNKNOWN); fail_unless (clip); assert_num_children (clip, 1); assert_num_in_track (track1, 1); assert_num_in_track (track2, 0); source = GES_CONTAINER_CHILDREN (clip)->data; fail_unless (ges_track_element_get_track (source) == track1); effect = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); _assert_add (clip, effect); effect2 = GES_TRACK_ELEMENT (ges_effect_new ("vertigotv")); _assert_add (clip, effect2); assert_num_children (clip, 3); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); fail_unless (ges_track_element_get_track (effect) == track1); fail_unless (ges_track_element_get_track (effect2) == track1); ges_timeline_element_set_child_properties (GES_TIMELINE_ELEMENT (clip), "font-desc", "Normal", "posx", 30, "posy", 50, "alpha", 0.1, "freq", 449.0, "scratch-lines", 2, NULL); ctrl_source = GST_CONTROL_SOURCE (gst_interpolation_control_source_new ()); g_object_set (G_OBJECT (ctrl_source), "mode", GST_INTERPOLATION_MODE_CUBIC, NULL); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 0, 20.0)); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 5, 45.0)); fail_unless (ges_track_element_set_control_source (source, ctrl_source, "posx", "direct-absolute")); gst_object_unref (ctrl_source); ctrl_source = GST_CONTROL_SOURCE (gst_interpolation_control_source_new ()); g_object_set (G_OBJECT (ctrl_source), "mode", GST_INTERPOLATION_MODE_LINEAR, NULL); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 2, 0.1)); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 5, 0.7)); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 8, 0.3)); fail_unless (ges_track_element_set_control_source (source, ctrl_source, "alpha", "direct")); gst_object_unref (ctrl_source); ctrl_source = GST_CONTROL_SOURCE (gst_interpolation_control_source_new ()); g_object_set (G_OBJECT (ctrl_source), "mode", GST_INTERPOLATION_MODE_NONE, NULL); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 0, 1.0)); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 4, 7.0)); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 8, 3.0)); fail_unless (ges_track_element_set_control_source (effect, ctrl_source, "scratch-lines", "direct-absolute")); gst_object_unref (ctrl_source); /* can't add to a track that does not belong to the timeline */ fail_if (ges_clip_add_child_to_track (clip, source, track2, &error)); assert_num_children (clip, 3); fail_unless (ges_track_element_get_track (source) == track1); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); /* programming/usage error gives no error code/message */ fail_if (error); /* can't add the clip to a track that already contains our source */ fail_if (ges_clip_add_child_to_track (clip, source, track1, &error)); assert_num_children (clip, 3); fail_unless (ges_track_element_get_track (source) == track1); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); fail_if (error); /* can't remove a core element from its track whilst a non-core sits * above it */ fail_if (ges_track_remove_element (track1, source)); assert_num_children (clip, 3); fail_unless (ges_track_element_get_track (source) == track1); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); /* can not add to the same track as it is currently in */ fail_if (ges_clip_add_child_to_track (clip, effect, track1, &error)); fail_unless (ges_track_element_get_track (effect) == track1); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); fail_if (error); /* adding another video track, select-tracks-for-object will do nothing * since no each track element is already part of a track */ fail_unless (ges_timeline_add_track (timeline, track2)); assert_num_children (clip, 3); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); /* can not add effect to a track that does not contain a core child */ fail_if (ges_clip_add_child_to_track (clip, effect, track2, &error)); assert_num_children (clip, 3); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); fail_if (error); /* can add core */ added = ges_clip_add_child_to_track (clip, source, track2, &error); fail_unless (added); assert_num_children (clip, 4); fail_unless (added != source); fail_unless (ges_track_element_get_track (source) == track1); fail_unless (ges_track_element_get_track (added) == track2); assert_num_in_track (track1, 3); assert_num_in_track (track2, 1); fail_if (error); assert_equal_children_properties (added, source); assert_equal_bindings (added, source); /* can now add non-core */ assert_equals_int (0, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect))); assert_equals_int (1, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect2))); added2 = ges_clip_add_child_to_track (clip, effect, track2, &error); fail_unless (added2); fail_if (error); assert_num_children (clip, 5); fail_unless (added2 != effect); fail_unless (ges_track_element_get_track (effect) == track1); fail_unless (ges_track_element_get_track (added2) == track2); assert_num_in_track (track1, 3); assert_num_in_track (track2, 2); assert_equal_children_properties (added2, effect); assert_equal_bindings (added2, effect); assert_equals_int (0, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect))); assert_equals_int (1, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (added2))); assert_equals_int (2, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect2))); added3 = ges_clip_add_child_to_track (clip, effect2, track2, &error); fail_unless (added3); fail_if (error); assert_num_children (clip, 6); fail_unless (added3 != effect2); fail_unless (ges_track_element_get_track (effect2) == track1); fail_unless (ges_track_element_get_track (added3) == track2); assert_num_in_track (track1, 3); assert_num_in_track (track2, 3); assert_equal_children_properties (added3, effect2); assert_equal_bindings (added3, effect2); /* priorities within new track match that in previous track! */ assert_equals_int (0, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect))); assert_equals_int (1, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (added2))); assert_equals_int (2, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect2))); assert_equals_int (3, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (added3))); /* removing core from the container, empties the non-core from their * tracks */ gst_object_ref (added); _assert_remove (clip, added); assert_num_children (clip, 5); fail_unless (ges_track_element_get_track (source) == track1); fail_if (ges_track_element_get_track (added)); fail_if (ges_track_element_get_track (added2)); fail_unless (GES_TIMELINE_ELEMENT_PARENT (added) == NULL); fail_unless (GES_TIMELINE_ELEMENT_PARENT (added2) == GES_TIMELINE_ELEMENT (clip)); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); gst_object_unref (added); _assert_remove (clip, added2); _assert_remove (clip, added3); assert_num_children (clip, 3); assert_num_in_track (track1, 3); assert_num_in_track (track2, 0); /* remove from layer empties all children from the tracks */ gst_object_ref (clip); fail_unless (ges_layer_remove_clip (layer, clip)); assert_num_children (clip, 3); fail_if (ges_track_element_get_track (source)); fail_if (ges_track_element_get_track (effect)); assert_num_in_track (track1, 0); assert_num_in_track (track2, 0); /* add different sources to the layer */ fail_unless (ges_layer_add_asset (layer, asset, 0, 0, 10, GES_TRACK_TYPE_UNKNOWN)); fail_unless (ges_layer_add_asset (layer, asset, 20, 0, 10, GES_TRACK_TYPE_UNKNOWN)); fail_unless (clip2 = ges_layer_add_asset (layer, asset, 25, 0, 10, GES_TRACK_TYPE_UNKNOWN)); assert_num_children (clip2, 2); /* 3 sources + 1 transition */ assert_num_in_track (track1, 4); assert_num_in_track (track2, 4); /* removing the track from the timeline empties it of track elements */ gst_object_ref (track2); fail_unless (ges_timeline_remove_track (timeline, track2)); /* but children remain in the clips */ assert_num_children (clip2, 2); assert_num_in_track (track1, 4); assert_num_in_track (track2, 0); gst_object_unref (track2); /* add clip back in, but don't select any tracks */ g_signal_connect (timeline, "select-tracks-for-object", G_CALLBACK (_select_none), &selection_called); /* can add the clip to the layer, despite a source existing between * 0 and 10 because the clip will not fill any track */ /* NOTE: normally this would be useless because it would not trigger * the creation of any core children. But clip currently still has * its core children */ fail_unless (ges_layer_add_clip (layer, clip)); gst_object_unref (clip); /* one call for each child */ assert_equals_int (selection_called, 3); fail_if (ges_track_element_get_track (source)); fail_if (ges_track_element_get_track (effect)); assert_num_children (clip, 3); assert_num_in_track (track1, 4); /* can not add the source to the track because it would overlap another * source */ fail_if (ges_clip_add_child_to_track (clip, source, track1, &error)); assert_num_children (clip, 3); assert_num_in_track (track1, 4); assert_GESError (error, GES_ERROR_INVALID_OVERLAP_IN_TRACK); /* can not add source at time 23 because it would result in three * overlapping sources in the track */ assert_set_start (clip, 23); fail_if (ges_clip_add_child_to_track (clip, source, track1, &error)); assert_num_children (clip, 3); assert_num_in_track (track1, 4); assert_GESError (error, GES_ERROR_INVALID_OVERLAP_IN_TRACK); /* can add at 5, with overlap */ assert_set_start (clip, 5); added = ges_clip_add_child_to_track (clip, source, track1, &error); /* added is the source since it was not already in a track */ fail_unless (added == source); fail_if (error); assert_num_children (clip, 3); /* 4 sources + 2 transitions */ assert_num_in_track (track1, 6); /* also add effect */ added = ges_clip_add_child_to_track (clip, effect, track1, &error); /* added is the source since it was not already in a track */ fail_unless (added == effect); fail_if (error); assert_num_children (clip, 3); assert_num_in_track (track1, 7); added = ges_clip_add_child_to_track (clip, effect2, track1, &error); /* added is the source since it was not already in a track */ fail_unless (added == effect2); fail_if (error); assert_num_children (clip, 3); assert_num_in_track (track1, 8); assert_equals_int (0, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect))); assert_equals_int (1, ges_clip_get_top_effect_index (clip, GES_BASE_EFFECT (effect2))); gst_object_unref (timeline); gst_object_unref (asset); ges_deinit (); } GST_END_TEST; static void child_removed_cb (GESClip * clip, GESTimelineElement * effect, gboolean * called) { ASSERT_OBJECT_REFCOUNT (effect, "1 test ref + 1 keeping alive ref + " "emission ref", 3); *called = TRUE; } GST_START_TEST (test_clip_refcount_remove_child) { GESClip *clip; GESTrack *track; gboolean called; GESTrackElement *effect, *source; GESTimeline *timeline; GESLayer *layer; ges_init (); timeline = ges_timeline_new (); track = GES_TRACK (ges_audio_track_new ()); fail_unless (ges_timeline_add_track (timeline, track)); layer = ges_timeline_append_layer (timeline); clip = GES_CLIP (ges_test_clip_new ()); fail_unless (ges_layer_add_clip (layer, clip)); assert_num_children (clip, 1); assert_num_in_track (track, 1); source = GES_CONTAINER_CHILDREN (clip)->data; ASSERT_OBJECT_REFCOUNT (source, "1 for the container + 1 for the track" " + 1 timeline", 3); effect = GES_TRACK_ELEMENT (ges_effect_new ("identity")); fail_unless (ges_track_add_element (track, effect)); assert_num_in_track (track, 2); ASSERT_OBJECT_REFCOUNT (effect, "1 for the track + 1 timeline", 2); _assert_add (clip, effect); assert_num_children (clip, 2); ASSERT_OBJECT_REFCOUNT (effect, "1 for the container + 1 for the track" " + 1 timeline", 3); fail_unless (ges_track_remove_element (track, effect)); ASSERT_OBJECT_REFCOUNT (effect, "1 for the container", 1); g_signal_connect (clip, "child-removed", G_CALLBACK (child_removed_cb), &called); gst_object_ref (effect); _assert_remove (clip, effect); fail_unless (called == TRUE); ASSERT_OBJECT_REFCOUNT (effect, "1 test ref", 1); gst_object_unref (effect); check_destroyed (G_OBJECT (timeline), G_OBJECT (track), G_OBJECT (layer), G_OBJECT (clip), G_OBJECT (source), NULL); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_clip_find_track_element) { GESClip *clip; GList *foundelements; GESTimeline *timeline; GESLayer *layer; GESTrack *track, *track1, *track2; guint selection_called = 0; GESTrackElement *effect, *effect1, *effect2, *foundelem, *video_source; ges_init (); track = GES_TRACK (ges_audio_track_new ()); track1 = GES_TRACK (ges_audio_track_new ()); track2 = GES_TRACK (ges_video_track_new ()); timeline = ges_timeline_new (); fail_unless (ges_timeline_add_track (timeline, track)); fail_unless (ges_timeline_add_track (timeline, track1)); fail_unless (ges_timeline_add_track (timeline, track2)); layer = ges_timeline_append_layer (timeline); clip = GES_CLIP (ges_test_clip_new ()); /* should have a source in every track */ fail_unless (ges_layer_add_clip (layer, clip)); assert_num_children (clip, 3); assert_num_in_track (track, 1); assert_num_in_track (track1, 1); assert_num_in_track (track2, 1); g_signal_connect (timeline, "select-tracks-for-object", G_CALLBACK (_select_none), &selection_called); effect = GES_TRACK_ELEMENT (ges_effect_new ("audio identity")); fail_unless (ges_track_add_element (track, effect)); _assert_add (clip, effect); effect1 = GES_TRACK_ELEMENT (ges_effect_new ("audio identity")); fail_unless (ges_track_add_element (track1, effect1)); _assert_add (clip, effect1); effect2 = GES_TRACK_ELEMENT (ges_effect_new ("identity")); fail_unless (ges_track_add_element (track2, effect2)); _assert_add (clip, effect2); fail_if (selection_called); assert_num_children (clip, 6); assert_num_in_track (track, 2); assert_num_in_track (track1, 2); assert_num_in_track (track2, 2); foundelem = ges_clip_find_track_element (clip, track, GES_TYPE_EFFECT); fail_unless (foundelem == effect); gst_object_unref (foundelem); foundelem = ges_clip_find_track_element (clip, track1, GES_TYPE_EFFECT); fail_unless (foundelem == effect1); gst_object_unref (foundelem); foundelem = ges_clip_find_track_element (clip, track2, GES_TYPE_EFFECT); fail_unless (foundelem == effect2); gst_object_unref (foundelem); foundelem = ges_clip_find_track_element (clip, NULL, GES_TYPE_TRANSITION); fail_unless (foundelem == NULL); foundelem = ges_clip_find_track_element (clip, track, GES_TYPE_TRANSITION); fail_unless (foundelem == NULL); foundelem = ges_clip_find_track_element (clip, track1, GES_TYPE_TRANSITION); fail_unless (foundelem == NULL); foundelem = ges_clip_find_track_element (clip, track2, GES_TYPE_TRANSITION); fail_unless (foundelem == NULL); foundelem = ges_clip_find_track_element (clip, track, GES_TYPE_SOURCE); fail_unless (GES_IS_AUDIO_TEST_SOURCE (foundelem)); gst_object_unref (foundelem); foundelem = ges_clip_find_track_element (clip, track1, GES_TYPE_SOURCE); fail_unless (GES_IS_AUDIO_TEST_SOURCE (foundelem)); gst_object_unref (foundelem); foundelem = ges_clip_find_track_element (clip, track2, GES_TYPE_SOURCE); fail_unless (GES_IS_VIDEO_TEST_SOURCE (foundelem)); gst_object_unref (foundelem); video_source = ges_clip_find_track_element (clip, NULL, GES_TYPE_VIDEO_TEST_SOURCE); fail_unless (foundelem == video_source); gst_object_unref (video_source); foundelements = ges_clip_find_track_elements (clip, NULL, GES_TRACK_TYPE_AUDIO, G_TYPE_NONE); fail_unless_equals_int (g_list_length (foundelements), 4); g_list_free_full (foundelements, gst_object_unref); foundelements = ges_clip_find_track_elements (clip, NULL, GES_TRACK_TYPE_VIDEO, G_TYPE_NONE); fail_unless_equals_int (g_list_length (foundelements), 2); g_list_free_full (foundelements, gst_object_unref); foundelements = ges_clip_find_track_elements (clip, NULL, GES_TRACK_TYPE_UNKNOWN, GES_TYPE_SOURCE); fail_unless_equals_int (g_list_length (foundelements), 3); fail_unless (g_list_find (foundelements, video_source)); g_list_free_full (foundelements, gst_object_unref); foundelements = ges_clip_find_track_elements (clip, NULL, GES_TRACK_TYPE_UNKNOWN, GES_TYPE_EFFECT); fail_unless_equals_int (g_list_length (foundelements), 3); fail_unless (g_list_find (foundelements, effect)); fail_unless (g_list_find (foundelements, effect1)); fail_unless (g_list_find (foundelements, effect2)); g_list_free_full (foundelements, gst_object_unref); foundelements = ges_clip_find_track_elements (clip, NULL, GES_TRACK_TYPE_VIDEO, GES_TYPE_SOURCE); fail_unless_equals_int (g_list_length (foundelements), 1); fail_unless (foundelements->data == video_source); g_list_free_full (foundelements, gst_object_unref); foundelements = ges_clip_find_track_elements (clip, track2, GES_TRACK_TYPE_UNKNOWN, GES_TYPE_SOURCE); fail_unless_equals_int (g_list_length (foundelements), 1); fail_unless (foundelements->data == video_source); g_list_free_full (foundelements, gst_object_unref); foundelements = ges_clip_find_track_elements (clip, track2, GES_TRACK_TYPE_UNKNOWN, G_TYPE_NONE); fail_unless_equals_int (g_list_length (foundelements), 2); fail_unless (g_list_find (foundelements, effect2)); fail_unless (g_list_find (foundelements, video_source)); g_list_free_full (foundelements, gst_object_unref); foundelements = ges_clip_find_track_elements (clip, track1, GES_TRACK_TYPE_UNKNOWN, GES_TYPE_EFFECT); fail_unless_equals_int (g_list_length (foundelements), 1); fail_unless (foundelements->data == effect1); g_list_free_full (foundelements, gst_object_unref); /* NOTE: search in *either* track or track type * TODO 2.0: this should be an AND condition, rather than OR */ foundelements = ges_clip_find_track_elements (clip, track, GES_TRACK_TYPE_VIDEO, G_TYPE_NONE); fail_unless_equals_int (g_list_length (foundelements), 4); fail_unless (g_list_find (foundelements, effect)); fail_unless (g_list_find (foundelements, effect2)); fail_unless (g_list_find (foundelements, video_source)); g_list_free_full (foundelements, gst_object_unref); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_effects_priorities) { GESClip *clip; GESTimeline *timeline; GESTrack *audio_track, *video_track; GESLayer *layer, *layer1; GESTrackElement *effect, *effect1, *effect2; ges_init (); clip = GES_CLIP (ges_test_clip_new ()); audio_track = GES_TRACK (ges_audio_track_new ()); video_track = GES_TRACK (ges_video_track_new ()); timeline = ges_timeline_new (); fail_unless (ges_timeline_add_track (timeline, audio_track)); fail_unless (ges_timeline_add_track (timeline, video_track)); layer = ges_timeline_append_layer (timeline); layer1 = ges_timeline_append_layer (timeline); ges_layer_add_clip (layer, clip); effect = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); _assert_add (clip, effect); effect1 = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); _assert_add (clip, effect1); effect2 = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); _assert_add (clip, effect2); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 0, _PRIORITY (effect)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 1, _PRIORITY (effect1)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, _PRIORITY (effect2)); fail_unless (ges_clip_set_top_effect_index (clip, GES_BASE_EFFECT (effect), 2)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 0, _PRIORITY (effect1)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 1, _PRIORITY (effect2)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, _PRIORITY (effect)); fail_unless (ges_clip_set_top_effect_index (clip, GES_BASE_EFFECT (effect), 0)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 0, _PRIORITY (effect)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 1, _PRIORITY (effect1)); fail_unless_equals_int (MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, _PRIORITY (effect2)); fail_unless (ges_clip_move_to_layer (clip, layer1)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 0, _PRIORITY (effect)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 1, _PRIORITY (effect1)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, _PRIORITY (effect2)); fail_unless (ges_clip_set_top_effect_index (clip, GES_BASE_EFFECT (effect), 2)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 0, _PRIORITY (effect1)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 1, _PRIORITY (effect2)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, _PRIORITY (effect)); fail_unless (ges_clip_set_top_effect_index (clip, GES_BASE_EFFECT (effect), 0)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 0, _PRIORITY (effect)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 1, _PRIORITY (effect1)); fail_unless_equals_int (LAYER_HEIGHT + MIN_NLE_PRIO + TRANSITIONS_HEIGHT + 2, _PRIORITY (effect2)); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; static void _count_cb (GObject * obj, GParamSpec * pspec, gint * count) { *count = *count + 1; } #define _assert_children_time_setter(clip, child, prop, setter, val1, val2) \ { \ gint clip_count = 0; \ gint child_count = 0; \ gchar *notify_name = g_strconcat ("notify::", prop, NULL); \ gchar *clip_name = GES_TIMELINE_ELEMENT_NAME (clip); \ gchar *child_name = NULL; \ g_signal_connect (clip, notify_name, G_CALLBACK (_count_cb), \ &clip_count); \ if (child) { \ child_name = GES_TIMELINE_ELEMENT_NAME (child); \ g_signal_connect (child, notify_name, G_CALLBACK (_count_cb), \ &child_count); \ } \ \ fail_unless (setter (GES_TIMELINE_ELEMENT (clip), val1), \ "Failed to set the %s property for clip %s", prop, clip_name); \ assert_clip_children_time_val (clip, prop, val1); \ \ fail_unless (clip_count == 1, "The callback for the %s property was " \ "called %i times for clip %s, rather than once", \ prop, clip_count, clip_name); \ if (child) { \ fail_unless (child_count == 1, "The callback for the %s property " \ "was called %i times for the child %s of clip %s, rather than " \ "once", prop, child_count, child_name, clip_name); \ } \ \ clip_count = 0; \ if (child) { \ child_count = 0; \ fail_unless (setter (GES_TIMELINE_ELEMENT (child), val2), \ "Failed to set the %s property for the child %s of clip %s", \ prop, child_name, clip_name); \ fail_unless (child_count == 1, "The callback for the %s property " \ "was called %i more times for the child %s of clip %s, rather " \ "than once more", prop, child_count, child_name, clip_name); \ } else { \ fail_unless (setter (GES_TIMELINE_ELEMENT (clip), val2), \ "Failed to set the %s property for clip %s", prop, clip_name); \ } \ assert_clip_children_time_val (clip, prop, val2); \ \ fail_unless (clip_count == 1, "The callback for the %s property " \ "was called %i more times for clip %s, rather than once more", \ prop, clip_count, clip_name); \ assert_equals_int (g_signal_handlers_disconnect_by_func (clip, \ G_CALLBACK (_count_cb), &clip_count), 1); \ if (child) { \ assert_equals_int (g_signal_handlers_disconnect_by_func (child, \ G_CALLBACK (_count_cb), &child_count), 1); \ } \ \ g_free (notify_name); \ } static void _test_children_time_setting_on_clip (GESClip * clip, GESTrackElement * child) { _assert_children_time_setter (clip, child, "in-point", ges_timeline_element_set_inpoint, 11, 101); _assert_children_time_setter (clip, child, "in-point", ges_timeline_element_set_inpoint, 51, 1); _assert_children_time_setter (clip, child, "start", ges_timeline_element_set_start, 12, 102); _assert_children_time_setter (clip, child, "start", ges_timeline_element_set_start, 52, 2); _assert_children_time_setter (clip, child, "duration", ges_timeline_element_set_duration, 13, 103); _assert_children_time_setter (clip, child, "duration", ges_timeline_element_set_duration, 53, 3); } GST_START_TEST (test_children_time_setters) { GESTimeline *timeline; GESLayer *layer; GESClip *clips[] = { NULL, NULL }; gint i; ges_init (); timeline = ges_timeline_new_audio_video (); fail_unless (timeline); layer = ges_timeline_append_layer (timeline); clips[0] = GES_CLIP (ges_transition_clip_new (GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE)); clips[1] = GES_CLIP (ges_test_clip_new ()); for (i = 0; i < G_N_ELEMENTS (clips); i++) { GESClip *clip = clips[i]; GESContainer *group = GES_CONTAINER (ges_group_new ()); GList *children; GESTrackElement *child; /* no children */ _test_children_time_setting_on_clip (clip, NULL); /* child in timeline */ fail_unless (ges_layer_add_clip (layer, clip)); children = GES_CONTAINER_CHILDREN (clip); fail_unless (children); child = GES_TRACK_ELEMENT (children->data); /* make sure the child can have its in-point set */ ges_track_element_set_has_internal_source (child, TRUE); _test_children_time_setting_on_clip (clip, child); /* clip in a group */ _assert_add (group, clip); _test_children_time_setting_on_clip (clip, child); /* group is removed from the timeline and destroyed when empty */ _assert_remove (group, clip); /* child not in timeline */ gst_object_ref (clip); fail_unless (ges_layer_remove_clip (layer, clip)); children = GES_CONTAINER_CHILDREN (clip); fail_unless (children); child = GES_TRACK_ELEMENT (children->data); ges_track_element_set_has_internal_source (child, TRUE); _test_children_time_setting_on_clip (clip, child); gst_object_unref (clip); } gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_not_enough_internal_content_for_core) { GESTimeline *timeline; GESLayer *layer; GESAsset *asset; GError *error = NULL; ges_init (); timeline = ges_timeline_new_audio_video (); layer = ges_timeline_append_layer (timeline); asset = ges_asset_request (GES_TYPE_TEST_CLIP, "max-duration=30", NULL); fail_unless (asset); fail_if (ges_layer_add_asset_full (layer, asset, 0, 31, 10, GES_TRACK_TYPE_UNKNOWN, &error)); assert_GESError (error, GES_ERROR_NOT_ENOUGH_INTERNAL_CONTENT); gst_object_unref (timeline); gst_object_unref (asset); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_can_add_effect) { struct CanAddEffectData { GESClip *clip; gboolean can_add_effect; } clips[6]; guint i; gchar *uri; ges_init (); uri = ges_test_get_audio_video_uri (); clips[0] = (struct CanAddEffectData) { GES_CLIP (ges_test_clip_new ()), TRUE}; clips[1] = (struct CanAddEffectData) { GES_CLIP (ges_uri_clip_new (uri)), TRUE}; clips[2] = (struct CanAddEffectData) { GES_CLIP (ges_title_clip_new ()), TRUE}; clips[3] = (struct CanAddEffectData) { GES_CLIP (ges_effect_clip_new ("agingtv", "audioecho")), TRUE}; clips[4] = (struct CanAddEffectData) { GES_CLIP (ges_transition_clip_new (GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE)), FALSE}; clips[5] = (struct CanAddEffectData) { GES_CLIP (ges_text_overlay_clip_new ()), FALSE}; g_free (uri); for (i = 0; i < G_N_ELEMENTS (clips); i++) { GESClip *clip = clips[i].clip; GESTimelineElement *effect = GES_TIMELINE_ELEMENT (ges_effect_new ("agingtv")); gst_object_ref_sink (effect); gst_object_ref_sink (clip); fail_unless (clip); if (clips[i].can_add_effect) fail_unless (ges_container_add (GES_CONTAINER (clip), effect), "Could not add an effect to clip %s", GES_TIMELINE_ELEMENT_NAME (clip)); else fail_if (ges_container_add (GES_CONTAINER (clip), effect), "Could add an effect to clip %s, but we expect this to fail", GES_TIMELINE_ELEMENT_NAME (clip)); gst_object_unref (effect); gst_object_unref (clip); } ges_deinit (); } GST_END_TEST; #define _assert_active(el, active) \ fail_unless (ges_track_element_is_active (el) == active) #define _assert_set_active(el, active) \ fail_unless (ges_track_element_set_active (el, active)) GST_START_TEST (test_children_active) { GESTimeline *timeline; GESLayer *layer; GESClip *clip; GESTrack *track0, *track1, *select_track; GESTrackElement *effect0, *effect1, *effect2, *effect3; GESTrackElement *source0, *source1; ges_init (); timeline = ges_timeline_new (); track0 = GES_TRACK (ges_video_track_new ()); track1 = GES_TRACK (ges_video_track_new ()); fail_unless (ges_timeline_add_track (timeline, track0)); fail_unless (ges_timeline_add_track (timeline, track1)); layer = ges_timeline_append_layer (timeline); clip = GES_CLIP (ges_test_clip_new ()); fail_unless (ges_layer_add_clip (layer, clip)); assert_num_children (clip, 2); source0 = ges_clip_find_track_element (clip, track0, GES_TYPE_VIDEO_TEST_SOURCE); source1 = ges_clip_find_track_element (clip, track1, GES_TYPE_VIDEO_TEST_SOURCE); fail_unless (source0); fail_unless (source1); gst_object_unref (source0); gst_object_unref (source1); _assert_active (source0, TRUE); _assert_active (source1, TRUE); _assert_set_active (source0, FALSE); _assert_active (source0, FALSE); _assert_active (source1, TRUE); select_track = track0; g_signal_connect (timeline, "select-tracks-for-object", G_CALLBACK (_select_track), &select_track); /* add an active effect should become inactive to match the core */ effect0 = GES_TRACK_ELEMENT (ges_effect_new ("videobalance")); _assert_active (effect0, TRUE); _assert_add (clip, effect0); fail_if (select_track); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (source1, TRUE); /* adding inactive to track with inactive core does nothing */ effect1 = GES_TRACK_ELEMENT (ges_effect_new ("vertigotv")); _assert_active (effect1, TRUE); _assert_set_active (effect1, FALSE); _assert_active (effect1, FALSE); select_track = track0; _assert_add (clip, effect1); fail_if (select_track); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); /* adding active to track with active core does nothing */ effect2 = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); _assert_active (effect2, TRUE); select_track = track1; _assert_add (clip, effect2); fail_if (select_track); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); _assert_active (effect2, TRUE); /* adding inactive to track with active core does nothing */ effect3 = GES_TRACK_ELEMENT (ges_effect_new ("alpha")); _assert_active (effect3, TRUE); _assert_set_active (effect3, FALSE); _assert_active (effect3, FALSE); select_track = track1; _assert_add (clip, effect3); fail_if (select_track); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); _assert_active (effect2, TRUE); _assert_active (effect3, FALSE); /* activate a core does not change non-core */ _assert_set_active (source0, TRUE); _assert_active (source0, TRUE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); _assert_active (effect2, TRUE); _assert_active (effect3, FALSE); /* but de-activating a core will de-activate the non-core */ _assert_set_active (source1, FALSE); _assert_active (source0, TRUE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, FALSE); _assert_active (effect2, FALSE); _assert_active (effect3, FALSE); /* activate a non-core will activate the core */ _assert_set_active (effect3, TRUE); _assert_active (source0, TRUE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); _assert_active (effect2, FALSE); _assert_active (effect3, TRUE); /* if core is already active, nothing else happens */ _assert_set_active (effect0, TRUE); _assert_active (source0, TRUE); _assert_active (effect0, TRUE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); _assert_active (effect2, FALSE); _assert_active (effect3, TRUE); _assert_set_active (effect1, TRUE); _assert_active (source0, TRUE); _assert_active (effect0, TRUE); _assert_active (effect1, TRUE); _assert_active (source1, TRUE); _assert_active (effect2, FALSE); _assert_active (effect3, TRUE); _assert_set_active (effect2, TRUE); _assert_active (source0, TRUE); _assert_active (effect0, TRUE); _assert_active (effect1, TRUE); _assert_active (source1, TRUE); _assert_active (effect2, TRUE); _assert_active (effect3, TRUE); /* de-activate a core will de-active all the non-core */ _assert_set_active (source0, FALSE); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); _assert_active (effect2, TRUE); _assert_active (effect3, TRUE); /* de-activate a non-core does nothing else */ _assert_set_active (effect3, FALSE); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (source1, TRUE); _assert_active (effect2, TRUE); _assert_active (effect3, FALSE); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_children_inpoint) { GESTimeline *timeline; GESLayer *layer; GESTimelineElement *clip, *child0, *child1, *effect; GList *children; ges_init (); timeline = ges_timeline_new_audio_video (); fail_unless (timeline); layer = ges_timeline_append_layer (timeline); clip = GES_TIMELINE_ELEMENT (ges_test_clip_new ()); assert_set_start (clip, 5); assert_set_duration (clip, 20); assert_set_inpoint (clip, 30); CHECK_OBJECT_PROPS (clip, 5, 30, 20); fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip))); /* clip now has children */ children = GES_CONTAINER_CHILDREN (clip); fail_unless (children); child0 = children->data; fail_unless (children->next); child1 = children->next->data; fail_unless (children->next->next == NULL); fail_unless (ges_track_element_has_internal_source (GES_TRACK_ELEMENT (child0))); fail_unless (ges_track_element_has_internal_source (GES_TRACK_ELEMENT (child1))); CHECK_OBJECT_PROPS (clip, 5, 30, 20); CHECK_OBJECT_PROPS (child0, 5, 30, 20); CHECK_OBJECT_PROPS (child1, 5, 30, 20); /* add a non-core element */ effect = GES_TIMELINE_ELEMENT (ges_effect_new ("agingtv")); fail_if (ges_track_element_has_internal_source (GES_TRACK_ELEMENT (effect))); /* allow us to choose our own in-point */ ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (effect), TRUE); assert_set_start (effect, 104); assert_set_duration (effect, 53); assert_set_inpoint (effect, 67); /* adding the effect will change its start and duration, but not its * in-point */ _assert_add (clip, effect); CHECK_OBJECT_PROPS (clip, 5, 30, 20); CHECK_OBJECT_PROPS (child0, 5, 30, 20); CHECK_OBJECT_PROPS (child1, 5, 30, 20); CHECK_OBJECT_PROPS (effect, 5, 67, 20); /* register child0 as having no internal source, which means its * in-point will be set to 0 */ ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (child0), FALSE); CHECK_OBJECT_PROPS (clip, 5, 30, 20); CHECK_OBJECT_PROPS (child0, 5, 0, 20); CHECK_OBJECT_PROPS (child1, 5, 30, 20); CHECK_OBJECT_PROPS (effect, 5, 67, 20); /* should not be able to set the in-point to non-zero */ assert_fail_set_inpoint (child0, 40); CHECK_OBJECT_PROPS (clip, 5, 30, 20); CHECK_OBJECT_PROPS (child0, 5, 0, 20); CHECK_OBJECT_PROPS (child1, 5, 30, 20); CHECK_OBJECT_PROPS (effect, 5, 67, 20); /* when we set the in-point on a core-child with an internal source we * also set the clip and siblings with the same features */ assert_set_inpoint (child1, 50); CHECK_OBJECT_PROPS (clip, 5, 50, 20); /* child with no internal source not changed */ CHECK_OBJECT_PROPS (child0, 5, 0, 20); CHECK_OBJECT_PROPS (child1, 5, 50, 20); /* non-core no changed */ CHECK_OBJECT_PROPS (effect, 5, 67, 20); /* setting back to having internal source will put in sync with the * in-point of the clip */ ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (child0), TRUE); CHECK_OBJECT_PROPS (clip, 5, 50, 20); CHECK_OBJECT_PROPS (child0, 5, 50, 20); CHECK_OBJECT_PROPS (child1, 5, 50, 20); CHECK_OBJECT_PROPS (effect, 5, 67, 20); assert_set_inpoint (child0, 40); CHECK_OBJECT_PROPS (clip, 5, 40, 20); CHECK_OBJECT_PROPS (child0, 5, 40, 20); CHECK_OBJECT_PROPS (child1, 5, 40, 20); CHECK_OBJECT_PROPS (effect, 5, 67, 20); /* setting in-point on effect shouldn't change any other siblings */ assert_set_inpoint (effect, 77); CHECK_OBJECT_PROPS (clip, 5, 40, 20); CHECK_OBJECT_PROPS (child0, 5, 40, 20); CHECK_OBJECT_PROPS (child1, 5, 40, 20); CHECK_OBJECT_PROPS (effect, 5, 77, 20); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_children_max_duration) { GESTimeline *timeline; GESLayer *layer; gchar *uri; GESTimelineElement *child0, *child1, *effect; guint i; GstClockTime max_duration, new_max; GList *children; struct { GESTimelineElement *clip; GstClockTime max_duration; } clips[] = { { NULL, GST_SECOND}, { NULL, GST_CLOCK_TIME_NONE} }; ges_init (); timeline = ges_timeline_new_audio_video (); fail_unless (timeline); layer = ges_timeline_append_layer (timeline); uri = ges_test_get_audio_video_uri (); clips[0].clip = GES_TIMELINE_ELEMENT (ges_uri_clip_new (uri)); fail_unless (clips[0].clip); g_free (uri); clips[1].clip = GES_TIMELINE_ELEMENT (ges_test_clip_new ()); for (i = 0; i < G_N_ELEMENTS (clips); i++) { GESTimelineElement *clip = clips[i].clip; max_duration = clips[i].max_duration; fail_unless_equals_uint64 (_MAX_DURATION (clip), max_duration); assert_set_start (clip, 5); assert_set_duration (clip, 20); assert_set_inpoint (clip, 30); /* can set the max duration the clip to anything whilst it has * no core child */ assert_set_max_duration (clip, 150); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 150); /* add a non-core element */ effect = GES_TIMELINE_ELEMENT (ges_effect_new ("agingtv")); fail_if (ges_track_element_has_internal_source (GES_TRACK_ELEMENT (effect))); /* allow us to choose our own max-duration */ ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (effect), TRUE); assert_set_start (effect, 104); assert_set_duration (effect, 53); assert_set_max_duration (effect, 400); /* adding the effect will change its start and duration, but not its * max-duration (or in-point) */ _assert_add (clip, effect); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 150); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* only non-core, so can still set the max-duration */ assert_set_max_duration (clip, 200); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 200); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* removing should not change the max-duration we set on the clip */ gst_object_ref (effect); _assert_remove (clip, effect); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 200); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); _assert_add (clip, effect); gst_object_unref (effect); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 200); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* now add to a layer to create the core children */ fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip))); children = GES_CONTAINER_CHILDREN (clip); fail_unless (children); fail_unless (GES_TIMELINE_ELEMENT (children->data) == effect); fail_unless (children->next); child0 = children->next->data; fail_unless (children->next->next); child1 = children->next->next->data; fail_unless (children->next->next->next == NULL); fail_unless (ges_track_element_has_internal_source (GES_TRACK_ELEMENT (child0))); fail_unless (ges_track_element_has_internal_source (GES_TRACK_ELEMENT (child1))); if (GES_IS_URI_CLIP (clip)) new_max = max_duration; else /* need a valid clock time that is not too large */ new_max = 500; /* added children do not change the clip's max-duration, but will * instead set it to the minimum value of its children */ CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, max_duration); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, max_duration); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, max_duration); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* when setting max_duration of core children, clip will take the * minimum value */ assert_set_max_duration (child0, new_max - 1); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 1); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max - 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, max_duration); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_set_max_duration (child1, new_max - 2); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max - 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_set_max_duration (child0, new_max + 1); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* can not set in-point above max_duration, nor max_duration below * in-point */ assert_fail_set_max_duration (child0, 29); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_fail_set_max_duration (child1, 29); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_fail_set_max_duration (clip, 29); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* can't set the inpoint to (new_max), even though it is lower than * our own max-duration (new_max + 1) because it is too high for our * sibling child1 */ assert_fail_set_inpoint (child0, new_max); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_fail_set_inpoint (child1, new_max); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_fail_set_inpoint (clip, new_max); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* setting below new_max is ok */ assert_set_inpoint (child0, 15); CHECK_OBJECT_PROPS_MAX (clip, 5, 15, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 15, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 15, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_set_inpoint (child1, 25); CHECK_OBJECT_PROPS_MAX (clip, 5, 25, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 25, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 25, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_set_inpoint (clip, 30); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* non-core has no effect */ assert_set_max_duration (effect, new_max + 500); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, new_max + 500); /* can set the in-point of non-core to be higher than the max_duration * of the clip */ assert_set_inpoint (effect, new_max + 2); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, new_max + 2, 20, new_max + 500); /* but not higher than our own */ assert_fail_set_inpoint (effect, new_max + 501); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, new_max + 2, 20, new_max + 500); assert_fail_set_max_duration (effect, new_max + 1); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, new_max + 2, 20, new_max + 500); assert_set_inpoint (effect, 0); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, new_max + 500); assert_set_max_duration (effect, 400); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, new_max + 1); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, new_max - 2); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* setting on the clip will set all the core children to the same * value */ assert_set_max_duration (clip, 180); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 180); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, 180); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, 180); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* register child0 as having no internal source, which means its * in-point will be set to 0 and max-duration set to * GST_CLOCK_TIME_NONE */ ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (child0), FALSE); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 180); CHECK_OBJECT_PROPS_MAX (child0, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, 180); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* should not be able to set the max-duration to a valid time */ assert_fail_set_max_duration (child0, 40); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 180); CHECK_OBJECT_PROPS_MAX (child0, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, 180); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* same with child1 */ /* clock time of the clip should now be GST_CLOCK_TIME_NONE */ ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (child1), FALSE); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child0, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child1, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* should not be able to set the max of the clip to anything else * when it has no core children with an internal source */ assert_fail_set_max_duration (clip, 150); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child0, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child1, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* setting back to having an internal source will not immediately * change the max-duration (unlike in-point) */ ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (child0), TRUE); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child1, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* can now set the max-duration, which will effect the clip */ assert_set_max_duration (child0, 140); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child1, 5, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); ges_track_element_set_has_internal_source (GES_TRACK_ELEMENT (child1), TRUE); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); assert_set_max_duration (child1, 130); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 130); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, 130); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* removing a child may change the max_duration of the clip */ gst_object_ref (child0); gst_object_ref (child1); gst_object_ref (effect); /* removing non-core does nothing */ _assert_remove (clip, effect); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 130); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, 130); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* new minimum max-duration for the clip when we remove child1 */ _assert_remove (clip, child1); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, 130); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); /* with no core-children, the max-duration of the clip is set to * GST_CLOCK_TIME_NONE */ _assert_remove (clip, child0); CHECK_OBJECT_PROPS_MAX (clip, 5, 30, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (child0, 5, 30, 20, 140); CHECK_OBJECT_PROPS_MAX (child1, 5, 30, 20, 130); CHECK_OBJECT_PROPS_MAX (effect, 5, 0, 20, 400); fail_unless (ges_layer_remove_clip (layer, GES_CLIP (clip))); gst_object_unref (child0); gst_object_unref (child1); gst_object_unref (effect); } gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; #define _assert_duration_limit(clip, expect) \ assert_equals_uint64 (ges_clip_get_duration_limit (GES_CLIP (clip)), expect) GST_START_TEST (test_duration_limit) { GESTimeline *timeline; GESLayer *layer; GESClip *clip; GESTrackElement *video_source, *audio_source; GESTrackElement *effect1, *effect2, *effect3; GESTrack *track1, *track2; gint limit_notify_count = 0; gint duration_notify_count = 0; ges_init (); timeline = ges_timeline_new (); track1 = GES_TRACK (ges_video_track_new ()); track2 = GES_TRACK (ges_audio_track_new ()); fail_unless (ges_timeline_add_track (timeline, track1)); fail_unless (ges_timeline_add_track (timeline, track2)); /* add track3 later */ layer = ges_timeline_append_layer (timeline); clip = GES_CLIP (ges_test_clip_new ()); g_signal_connect (clip, "notify::duration-limit", G_CALLBACK (_count_cb), &limit_notify_count); g_signal_connect (clip, "notify::duration", G_CALLBACK (_count_cb), &duration_notify_count); /* no limit to begin with */ _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); /* add effects */ effect1 = GES_TRACK_ELEMENT (ges_effect_new ("textoverlay")); ges_track_element_set_has_internal_source (effect1, TRUE); effect2 = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); ges_track_element_set_has_internal_source (effect2, TRUE); effect3 = GES_TRACK_ELEMENT (ges_effect_new ("audioecho")); ges_track_element_set_has_internal_source (effect3, TRUE); _assert_add (clip, effect1); _assert_add (clip, effect2); _assert_add (clip, effect3); assert_num_children (clip, 3); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 0); assert_equals_int (duration_notify_count, 0); /* no change in duration limit whilst children are not in any track */ assert_set_max_duration (effect1, 20); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 0); assert_equals_int (duration_notify_count, 0); assert_set_inpoint (effect1, 5); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 0); assert_equals_int (duration_notify_count, 0); /* set a duration that will be above the duration-limit */ assert_set_duration (clip, 20); assert_equals_int (duration_notify_count, 1); /* add to layer to create sources */ fail_unless (ges_layer_add_clip (layer, clip)); /* duration-limit changes once because of effect1 */ _assert_duration_limit (clip, 15); assert_equals_int (limit_notify_count, 1); assert_equals_int (duration_notify_count, 2); /* duration has automatically been set to the duration-limit */ CHECK_OBJECT_PROPS_MAX (clip, 0, 0, 15, GST_CLOCK_TIME_NONE); assert_num_children (clip, 5); assert_num_in_track (track1, 3); assert_num_in_track (track2, 2); video_source = ges_clip_find_track_element (clip, track1, GES_TYPE_SOURCE); fail_unless (video_source); gst_object_unref (video_source); audio_source = ges_clip_find_track_element (clip, track2, GES_TYPE_SOURCE); fail_unless (audio_source); gst_object_unref (audio_source); CHECK_OBJECT_PROPS_MAX (video_source, 0, 0, 15, GST_CLOCK_TIME_NONE); fail_unless (ges_track_element_get_track (video_source) == track1); fail_unless (ges_track_element_get_track_type (video_source) == GES_TRACK_TYPE_VIDEO); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 0, 15, GST_CLOCK_TIME_NONE); fail_unless (ges_track_element_get_track (audio_source) == track2); fail_unless (ges_track_element_get_track_type (audio_source) == GES_TRACK_TYPE_AUDIO); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); fail_unless (ges_track_element_get_track (effect1) == track1); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 15, GST_CLOCK_TIME_NONE); fail_unless (ges_track_element_get_track (effect2) == track1); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, GST_CLOCK_TIME_NONE); fail_unless (ges_track_element_get_track (effect3) == track2); /* Make effect1 inactive, which will remove the duration-limit */ fail_unless (ges_track_element_set_active (effect1, FALSE)); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 2); /* duration is unchanged */ assert_equals_int (duration_notify_count, 2); CHECK_OBJECT_PROPS_MAX (clip, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (video_source, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, GST_CLOCK_TIME_NONE); /* changing the in-point does not change the duration limit whilst * there is no max-duration */ assert_set_inpoint (clip, 10); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 2); assert_equals_int (duration_notify_count, 2); CHECK_OBJECT_PROPS_MAX (clip, 0, 10, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (video_source, 0, 10, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 10, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, GST_CLOCK_TIME_NONE); assert_set_max_duration (video_source, 40); _assert_duration_limit (clip, 30); assert_equals_int (limit_notify_count, 3); assert_equals_int (duration_notify_count, 2); CHECK_OBJECT_PROPS_MAX (clip, 0, 10, 15, 40); CHECK_OBJECT_PROPS_MAX (video_source, 0, 10, 15, 40); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 10, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, GST_CLOCK_TIME_NONE); /* set in-point using child */ assert_set_inpoint (audio_source, 15); _assert_duration_limit (clip, 25); assert_equals_int (limit_notify_count, 4); assert_equals_int (duration_notify_count, 2); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 40); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 40); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, GST_CLOCK_TIME_NONE); /* set max-duration of core children */ assert_set_max_duration (clip, 60); _assert_duration_limit (clip, 45); assert_equals_int (limit_notify_count, 5); assert_equals_int (duration_notify_count, 2); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 15, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, GST_CLOCK_TIME_NONE); /* can set duration up to the limit */ assert_set_duration (clip, 45); _assert_duration_limit (clip, 45); assert_equals_int (limit_notify_count, 5); assert_equals_int (duration_notify_count, 3); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 45, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 45, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 45, 60); /* effect1 has a duration that exceeds max-duration - in-point * ok since it is currently inactive */ CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 45, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 45, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 45, GST_CLOCK_TIME_NONE); /* limit the effects */ assert_set_max_duration (effect2, 70); _assert_duration_limit (clip, 45); assert_equals_int (limit_notify_count, 5); assert_equals_int (duration_notify_count, 3); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 45, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 45, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 45, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 45, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 0, 45, 70); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 45, GST_CLOCK_TIME_NONE); assert_set_inpoint (effect2, 40); _assert_duration_limit (clip, 30); assert_equals_int (limit_notify_count, 6); assert_equals_int (duration_notify_count, 4); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 30, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 30, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 30, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 30, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 30, 70); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 30, GST_CLOCK_TIME_NONE); /* no change */ assert_set_max_duration (effect3, 35); _assert_duration_limit (clip, 30); assert_equals_int (limit_notify_count, 6); assert_equals_int (duration_notify_count, 4); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 30, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 30, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 30, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 30, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 30, 70); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 30, 35); /* make effect1 active again */ fail_unless (ges_track_element_set_active (effect1, TRUE)); _assert_duration_limit (clip, 15); assert_equals_int (limit_notify_count, 7); assert_equals_int (duration_notify_count, 5); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 15, 70); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, 35); /* removing effect2 from track does not change limit */ fail_unless (ges_track_remove_element (track1, effect2)); _assert_duration_limit (clip, 15); assert_equals_int (limit_notify_count, 7); assert_equals_int (duration_notify_count, 5); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, 35); /* no track */ CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 15, 70); /* removing effect1 does */ fail_unless (ges_track_remove_element (track1, effect1)); _assert_duration_limit (clip, 35); assert_equals_int (limit_notify_count, 8); assert_equals_int (duration_notify_count, 5); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, 35); /* no track */ CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 15, 70); /* add back */ fail_unless (ges_track_add_element (track1, effect2)); _assert_duration_limit (clip, 30); assert_equals_int (limit_notify_count, 9); assert_equals_int (duration_notify_count, 5); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, 35); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 15, 70); /* no track */ CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); assert_set_duration (clip, 20); _assert_duration_limit (clip, 30); assert_equals_int (limit_notify_count, 9); assert_equals_int (duration_notify_count, 6); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 20, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 20, 60); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 20, 35); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 20, 60); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 20, 70); /* no track */ CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 20, 20); fail_unless (ges_track_add_element (track1, effect1)); _assert_duration_limit (clip, 15); assert_equals_int (limit_notify_count, 10); assert_equals_int (duration_notify_count, 7); CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, 35); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 15, 70); gst_object_ref (clip); fail_unless (ges_layer_remove_clip (layer, clip)); assert_num_in_track (track1, 0); assert_num_in_track (track2, 0); assert_num_children (clip, 5); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); /* may have several changes in duration limit as the children are * emptied from their tracks */ fail_unless (limit_notify_count > 10); assert_equals_int (duration_notify_count, 7); /* none in any track */ CHECK_OBJECT_PROPS_MAX (clip, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (audio_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect3, 0, 0, 15, 35); CHECK_OBJECT_PROPS_MAX (video_source, 0, 15, 15, 60); CHECK_OBJECT_PROPS_MAX (effect1, 0, 5, 15, 20); CHECK_OBJECT_PROPS_MAX (effect2, 0, 40, 15, 70); gst_object_unref (timeline); gst_object_unref (clip); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_can_set_duration_limit) { GESTimeline *timeline; GESLayer *layer; GESClip *clip; GESTrackElement *source0, *source1; GESTrackElement *effect0, *effect1, *effect2; GESTrack *track0, *track1; gint limit_notify_count = 0; GError *error = NULL; ges_init (); timeline = ges_timeline_new (); track0 = GES_TRACK (ges_video_track_new ()); track1 = GES_TRACK (ges_audio_track_new ()); fail_unless (ges_timeline_add_track (timeline, track0)); fail_unless (ges_timeline_add_track (timeline, track1)); /* add track3 later */ layer = ges_timeline_append_layer (timeline); /* place a dummy clip at the start of the layer */ clip = GES_CLIP (ges_test_clip_new ()); assert_set_start (clip, 0); assert_set_duration (clip, 20); fail_unless (ges_layer_add_clip (layer, clip)); /* the clip we will be editing overlaps the first clip at its start */ clip = GES_CLIP (ges_test_clip_new ()); g_signal_connect (clip, "notify::duration-limit", G_CALLBACK (_count_cb), &limit_notify_count); assert_set_start (clip, 10); assert_set_duration (clip, 20); fail_unless (ges_layer_add_clip (layer, clip)); source0 = ges_clip_find_track_element (clip, track0, GES_TYPE_VIDEO_TEST_SOURCE); source1 = ges_clip_find_track_element (clip, track1, GES_TYPE_AUDIO_TEST_SOURCE); fail_unless (source0); fail_unless (source1); gst_object_unref (source0); gst_object_unref (source1); assert_equals_int (limit_notify_count, 0); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (clip, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source0, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source1, 10, 0, 20, GST_CLOCK_TIME_NONE); assert_set_inpoint (clip, 16); assert_equals_int (limit_notify_count, 0); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, GST_CLOCK_TIME_NONE); assert_set_max_duration (clip, 36); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); /* add effects */ effect0 = GES_TRACK_ELEMENT (ges_effect_new ("agingtv")); effect1 = GES_TRACK_ELEMENT (ges_effect_new ("vertigotv")); effect2 = GES_TRACK_ELEMENT (ges_effect_new ("alpha")); ges_track_element_set_has_internal_source (effect0, TRUE); fail_unless (ges_track_element_has_internal_source (effect1) == FALSE); ges_track_element_set_has_internal_source (effect2, TRUE); assert_set_max_duration (effect0, 10); /* already set the track */ fail_unless (ges_track_add_element (track0, effect0)); /* cannot add because it would cause the duration-limit to go to 10, * causing a full overlap with the clip at the beginning of the layer */ gst_object_ref (effect0); fail_if (ges_container_add (GES_CONTAINER (clip), GES_TIMELINE_ELEMENT (effect0))); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); /* removing from the track and adding will work, but track selection * will fail */ fail_unless (ges_track_remove_element (track0, effect0)); _assert_add (clip, effect0); fail_if (ges_track_element_get_track (effect0)); gst_object_unref (effect0); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 10); fail_if (ges_clip_add_child_to_track (clip, effect0, track0, &error)); assert_GESError (error, GES_ERROR_INVALID_OVERLAP_IN_TRACK); /* set max-duration to 11 and we are fine to select a track */ assert_set_max_duration (effect0, 11); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 20); fail_unless (ges_clip_add_child_to_track (clip, effect0, track0, &error) == effect0); fail_if (error); assert_equals_int (limit_notify_count, 2); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 11, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 11, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 11, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 11); /* cannot set duration above the limit */ assert_fail_set_duration (clip, 12); assert_fail_set_duration (source0, 12); assert_fail_set_duration (effect0, 12); /* allow the max_duration to increase again */ assert_set_max_duration (effect0, 25); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 11, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 11, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 11, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); assert_set_duration (clip, 20); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); /* add another effect */ _assert_add (clip, effect1); fail_unless (ges_track_element_get_track (effect1) == track0); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); /* make source0 inactive and reduce its max-duration * note that this causes effect0 and effect1 to also become in-active */ _assert_set_active (source0, FALSE); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); /* can set a low max duration whilst the source is inactive */ assert_set_max_duration (source0, 26); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); /* add the last effect */ assert_set_inpoint (effect2, 7); assert_set_max_duration (effect2, 17); _assert_active (effect2, TRUE); /* safe to add because the source is inactive */ assert_equals_int (limit_notify_count, 3); _assert_add (clip, effect2); assert_equals_int (limit_notify_count, 3); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (effect2, FALSE); fail_unless (ges_track_element_get_track (effect2) == track0); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 16, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 16, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 16, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 17); /* want to make the source and its effects active again */ assert_set_inpoint (source0, 6); assert_set_max_duration (effect2, 33); assert_equals_int (limit_notify_count, 4); _assert_duration_limit (clip, 30); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); _assert_set_active (source0, TRUE); _assert_set_active (effect0, TRUE); _assert_set_active (effect1, TRUE); _assert_set_active (effect2, TRUE); assert_equals_int (limit_notify_count, 5); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); /* cannot set in-point of clip to 16, nor of either source */ assert_fail_set_inpoint (clip, 16); assert_fail_set_inpoint (source0, 16); assert_fail_set_inpoint (source1, 16); assert_equals_int (limit_notify_count, 5); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); /* can set just below */ assert_set_inpoint (source1, 15); assert_equals_int (limit_notify_count, 6); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 15, 11, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 15, 11, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 15, 11, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 11, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 11, 33); assert_set_inpoint (clip, 6); assert_set_duration (clip, 20); assert_equals_int (limit_notify_count, 7); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); /* cannot set in-point of non-core in a way that would cause limit to * drop */ assert_fail_set_inpoint (effect2, 23); assert_fail_set_inpoint (effect0, 15); assert_equals_int (limit_notify_count, 7); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); /* can set just below */ assert_set_inpoint (effect2, 22); assert_equals_int (limit_notify_count, 8); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 11, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 11, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 22, 11, 33); assert_set_inpoint (effect2, 7); assert_set_duration (clip, 20); assert_equals_int (limit_notify_count, 9); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); /* same but with max-duration */ /* core */ assert_fail_set_max_duration (clip, 16); assert_fail_set_max_duration (source0, 16); assert_fail_set_max_duration (source1, 16); assert_equals_int (limit_notify_count, 9); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 36); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); assert_set_max_duration (source1, 17); assert_equals_int (limit_notify_count, 10); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 11, 17); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 11, 17); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 11, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 11, 33); assert_set_max_duration (source1, 30); assert_set_duration (clip, 20); assert_equals_int (limit_notify_count, 11); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 30); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); assert_set_max_duration (clip, 17); assert_equals_int (limit_notify_count, 12); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 11, 17); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 11, 17); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 11, 17); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 11, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 11, 33); assert_set_max_duration (clip, 26); assert_set_duration (clip, 20); assert_equals_int (limit_notify_count, 13); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); /* non-core */ assert_fail_set_max_duration (effect0, 10); assert_fail_set_max_duration (effect2, 17); assert_equals_int (limit_notify_count, 13); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); assert_set_max_duration (effect2, 18); assert_equals_int (limit_notify_count, 14); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 11, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 11, 18); assert_set_max_duration (effect2, 33); assert_set_duration (clip, 20); assert_equals_int (limit_notify_count, 15); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 33); /* test setting active */ _assert_active (effect2, TRUE); _assert_set_active (effect2, FALSE); assert_set_max_duration (effect2, 17); assert_equals_int (limit_notify_count, 15); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 17); fail_if (ges_track_element_set_active (effect2, TRUE)); assert_equals_int (limit_notify_count, 15); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 7, 20, 17); assert_set_inpoint (effect2, 6); _assert_set_active (effect2, TRUE); assert_equals_int (limit_notify_count, 16); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 11, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 11, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 6, 11, 17); /* make source0 in-active */ _assert_active (source0, TRUE); _assert_set_active (source0, FALSE); _assert_active (source0, FALSE); _assert_active (effect0, FALSE); _assert_active (effect1, FALSE); _assert_active (effect2, FALSE); assert_set_duration (source0, 20); assert_equals_int (limit_notify_count, 17); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 6, 20, 17); /* lower duration-limit for source for when it becomes active */ assert_set_max_duration (source0, 16); assert_equals_int (limit_notify_count, 17); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 16); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 16); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 6, 20, 17); /* cannot make the source active */ fail_if (ges_track_element_set_active (source0, TRUE)); assert_equals_int (limit_notify_count, 17); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 16); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 16); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 6, 20, 17); /* nor can we make the effects active because this would activate the * source */ fail_if (ges_track_element_set_active (effect0, TRUE)); fail_if (ges_track_element_set_active (effect1, TRUE)); fail_if (ges_track_element_set_active (effect2, TRUE)); assert_equals_int (limit_notify_count, 17); _assert_duration_limit (clip, 20); CHECK_OBJECT_PROPS_MAX (clip, 10, 6, 20, 16); CHECK_OBJECT_PROPS_MAX (source0, 10, 6, 20, 16); CHECK_OBJECT_PROPS_MAX (source1, 10, 6, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 6, 20, 17); /* allow it to just succeed */ assert_set_inpoint (source0, 5); assert_equals_int (limit_notify_count, 18); _assert_duration_limit (clip, 21); CHECK_OBJECT_PROPS_MAX (clip, 10, 5, 20, 16); CHECK_OBJECT_PROPS_MAX (source0, 10, 5, 20, 16); CHECK_OBJECT_PROPS_MAX (source1, 10, 5, 20, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 20, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 20, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 6, 20, 17); _assert_set_active (effect1, TRUE); assert_equals_int (limit_notify_count, 19); _assert_duration_limit (clip, 11); CHECK_OBJECT_PROPS_MAX (clip, 10, 5, 11, 16); CHECK_OBJECT_PROPS_MAX (source0, 10, 5, 11, 16); CHECK_OBJECT_PROPS_MAX (source1, 10, 5, 11, 26); CHECK_OBJECT_PROPS_MAX (effect0, 10, 0, 11, 25); CHECK_OBJECT_PROPS_MAX (effect1, 10, 0, 11, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (effect2, 10, 6, 11, 17); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; #define _assert_set_rate(element, prop_name, rate, val) \ { \ GError *error = NULL; \ if (G_VALUE_TYPE (&val) == G_TYPE_DOUBLE) \ g_value_set_double (&val, rate); \ else if (G_VALUE_TYPE (&val) == G_TYPE_FLOAT) \ g_value_set_float (&val, rate); \ \ fail_unless (ges_timeline_element_set_child_property_full ( \ GES_TIMELINE_ELEMENT (element), prop_name, &val, &error)); \ fail_if (error); \ g_value_reset (&val); \ } #define _assert_fail_set_rate(element, prop_name, rate, val, code) \ { \ GError * error = NULL; \ if (G_VALUE_TYPE (&val) == G_TYPE_DOUBLE) \ g_value_set_double (&val, rate); \ else if (G_VALUE_TYPE (&val) == G_TYPE_FLOAT) \ g_value_set_float (&val, rate); \ \ fail_if (ges_timeline_element_set_child_property_full ( \ GES_TIMELINE_ELEMENT (element), prop_name, &val, &error)); \ assert_GESError (error, code); \ g_value_reset (&val); \ } #define _assert_rate_equal(element, prop_name, rate, val) \ { \ gdouble found = -1.0; \ fail_unless (ges_timeline_element_get_child_property ( \ GES_TIMELINE_ELEMENT (element), prop_name, &val)); \ \ if (G_VALUE_TYPE (&val) == G_TYPE_DOUBLE) \ found = g_value_get_double (&val); \ else if (G_VALUE_TYPE (&val) == G_TYPE_FLOAT) \ found = g_value_get_float (&val); \ \ fail_unless (found == rate, "found %s: %g != expected: %g", found, \ prop_name, rate); \ g_value_reset (&val); \ } GST_START_TEST (test_rate_effects_duration_limit) { GESTimeline *timeline; GESLayer *layer; GESClip *clip; GESTrackElement *source0, *source1; GESTrackElement *overlay0, *overlay1, *videorate, *pitch; GESTrack *track0, *track1; gint limit_notify_count = 0; GValue fval = G_VALUE_INIT; GValue dval = G_VALUE_INIT; ges_init (); g_value_init (&fval, G_TYPE_FLOAT); g_value_init (&dval, G_TYPE_DOUBLE); timeline = ges_timeline_new (); track0 = GES_TRACK (ges_video_track_new ()); track1 = GES_TRACK (ges_audio_track_new ()); fail_unless (ges_timeline_add_track (timeline, track0)); fail_unless (ges_timeline_add_track (timeline, track1)); layer = ges_timeline_append_layer (timeline); /* place a dummy clip at the start of the layer */ clip = GES_CLIP (ges_test_clip_new ()); assert_set_start (clip, 0); assert_set_duration (clip, 26); fail_unless (ges_layer_add_clip (layer, clip)); /* the clip we will be editing overlaps first clip by 16 at its start */ clip = GES_CLIP (ges_test_clip_new ()); g_signal_connect (clip, "notify::duration-limit", G_CALLBACK (_count_cb), &limit_notify_count); assert_set_start (clip, 10); assert_set_duration (clip, 64); fail_unless (ges_layer_add_clip (layer, clip)); source0 = ges_clip_find_track_element (clip, track0, GES_TYPE_VIDEO_TEST_SOURCE); source1 = ges_clip_find_track_element (clip, track1, GES_TYPE_AUDIO_TEST_SOURCE); fail_unless (source0); fail_unless (source1); gst_object_unref (source0); gst_object_unref (source1); assert_equals_int (limit_notify_count, 0); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (clip, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source0, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source1, 10, 0, 64, GST_CLOCK_TIME_NONE); assert_set_inpoint (clip, 13); assert_equals_int (limit_notify_count, 0); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, GST_CLOCK_TIME_NONE); assert_set_max_duration (clip, 77); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); /* add effects */ overlay0 = GES_TRACK_ELEMENT (ges_effect_new ("textoverlay")); ges_track_element_set_has_internal_source (overlay0, TRUE); videorate = GES_TRACK_ELEMENT (ges_effect_new ("videorate")); fail_unless (ges_base_effect_is_time_effect (GES_BASE_EFFECT (videorate))); overlay1 = GES_TRACK_ELEMENT (ges_effect_new ("textoverlay")); ges_track_element_set_has_internal_source (overlay1, TRUE); pitch = GES_TRACK_ELEMENT (ges_effect_new ("pitch")); fail_unless (ges_base_effect_is_time_effect (GES_BASE_EFFECT (pitch))); /* add overlay1 at highest priority */ _assert_add (clip, overlay1); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_set_rate (videorate, "rate", 4.0, dval); _assert_rate_equal (videorate, "rate", 4.0, dval); fail_unless (ges_track_add_element (track0, videorate)); /* cannot add videorate as it would cause the duration-limit to drop * to 16, causing a full overlap */ /* track keeps alive */ fail_if (ges_container_add (GES_CONTAINER (clip), GES_TIMELINE_ELEMENT (videorate))); /* setting to 1.0 makes it work again */ _assert_set_rate (videorate, "rate", 1.0, dval); _assert_add (clip, videorate); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); /* add second overlay at lower priority */ _assert_add (clip, overlay0); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); /* also add a pitch element in another track */ _assert_add (clip, pitch); _assert_set_rate (pitch, "rate", 1.0, fval); _assert_set_rate (pitch, "tempo", 1.0, fval); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); _assert_rate_equal (pitch, "rate", 1.0, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); fail_unless (ges_track_element_get_track (overlay0) == track0); fail_unless (ges_track_element_get_track (videorate) == track0); fail_unless (ges_track_element_get_track (overlay1) == track0); fail_unless (ges_track_element_get_track (pitch) == track1); /* flow in track0: * source0 -> overlay0 -> videorate -> overlay1 -> timeline output * * flow in track1: * source1 -> pitch -> timeline output */ /* cannot set the rates to 4.0 since this would cause a full overlap */ _assert_fail_set_rate (videorate, "rate", 4.0, dval, GES_ERROR_INVALID_OVERLAP_IN_TRACK); _assert_fail_set_rate (pitch, "rate", 4.0, fval, GES_ERROR_INVALID_OVERLAP_IN_TRACK); _assert_fail_set_rate (pitch, "tempo", 4.0, fval, GES_ERROR_INVALID_OVERLAP_IN_TRACK); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); _assert_rate_equal (pitch, "rate", 1.0, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* limit overlay0 */ assert_set_max_duration (overlay0, 91); assert_equals_int (limit_notify_count, 1); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 0, 64, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); _assert_rate_equal (pitch, "rate", 1.0, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); assert_set_inpoint (overlay0, 59); assert_equals_int (limit_notify_count, 2); _assert_duration_limit (clip, 32); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); _assert_rate_equal (pitch, "rate", 1.0, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* can set pitch rate to 2.0, but not videorate rate because videorate * shares a track with overlay0 */ _assert_set_rate (pitch, "rate", 2.0, fval); assert_equals_int (limit_notify_count, 2); _assert_fail_set_rate (videorate, "rate", 2.0, dval, GES_ERROR_INVALID_OVERLAP_IN_TRACK); assert_equals_int (limit_notify_count, 2); /* can't set tempo to 2.0 since overall effect would bring duration * limit too low */ _assert_fail_set_rate (pitch, "tempo", 2.0, fval, GES_ERROR_INVALID_OVERLAP_IN_TRACK); assert_equals_int (limit_notify_count, 2); _assert_duration_limit (clip, 32); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); _assert_rate_equal (pitch, "rate", 2.0, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* cannot set in-point of clip because pitch would cause limit to go * to 16 */ assert_fail_set_inpoint (clip, 45); /* same for max-duration of source1 */ assert_fail_set_max_duration (source1, 45); assert_equals_int (limit_notify_count, 2); _assert_duration_limit (clip, 32); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 1.0, dval); _assert_rate_equal (pitch, "rate", 2.0, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* can set rate to 0.5 */ _assert_set_rate (videorate, "rate", 0.5, dval); /* no change yet, since pitch rate is still 2.0 */ assert_equals_int (limit_notify_count, 2); _assert_duration_limit (clip, 32); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 2.0, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); _assert_set_rate (pitch, "rate", 0.5, fval); assert_equals_int (limit_notify_count, 3); /* duration-limit is 64 because overlay0 only has 32 nanoseconds of * content, stretched to 64 by videorate */ _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* setting the max-duration of the sources does not change the limit * since the limit on overlay0 is fine. * Note that pitch handles the unlimited duration (GST_CLOCK_TIME_NONE) * without any problems */ assert_set_max_duration (clip, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); assert_set_max_duration (clip, 77); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* limit overlay1. It should not be changes by the videorate element * since it acts at a lower priority * first make it last longer, so no change in duration-limit */ assert_set_max_duration (overlay1, 81); assert_equals_int (limit_notify_count, 3); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 32, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 32, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 32, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 0, 32, 81); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 32, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* now make it shorter */ assert_set_inpoint (overlay1, 51); assert_equals_int (limit_notify_count, 4); _assert_duration_limit (clip, 30); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 30, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 30, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 30, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 30, 91); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 30, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 30, 81); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 30, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* remove the overlay0 limit */ assert_set_max_duration (overlay0, GST_CLOCK_TIME_NONE); /* no change because of overlay1 */ assert_equals_int (limit_notify_count, 4); _assert_duration_limit (clip, 30); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 30, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 30, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 30, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 30, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 30, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 30, 81); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 30, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); assert_set_max_duration (overlay1, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 5); _assert_duration_limit (clip, 128); /* can set up to the limit */ assert_set_duration (clip, 128); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 128, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 128, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 128, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 128, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 128, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 128, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 128, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* tempo contributes the same factor as rate */ _assert_set_rate (pitch, "tempo", 2.0, fval); assert_equals_int (limit_notify_count, 6); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 2.0, fval); _assert_set_rate (videorate, "rate", 0.1, dval); assert_equals_int (limit_notify_count, 6); _assert_set_rate (pitch, "tempo", 0.5, fval); assert_equals_int (limit_notify_count, 7); _assert_duration_limit (clip, 256); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.1, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 0.5, fval); _assert_set_rate (pitch, "tempo", 1.0, fval); assert_equals_int (limit_notify_count, 8); _assert_set_rate (videorate, "rate", 0.5, dval); assert_equals_int (limit_notify_count, 8); _assert_duration_limit (clip, 128); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* make videorate in-active */ fail_unless (ges_track_element_set_active (videorate, FALSE)); assert_equals_int (limit_notify_count, 9); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); fail_unless (ges_track_element_set_active (videorate, TRUE)); assert_equals_int (limit_notify_count, 10); _assert_duration_limit (clip, 128); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (pitch, 10, 0, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); _assert_rate_equal (pitch, "rate", 0.5, fval); _assert_rate_equal (pitch, "tempo", 1.0, fval); /* removing pitch, same effect as making inactive */ _assert_remove (clip, pitch); assert_equals_int (limit_notify_count, 11); _assert_duration_limit (clip, 64); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); /* no max-duration will give unlimited limit */ assert_set_max_duration (source1, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 12); _assert_duration_limit (clip, 128); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, 77); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); assert_set_max_duration (source0, GST_CLOCK_TIME_NONE); assert_equals_int (limit_notify_count, 13); _assert_duration_limit (clip, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (clip, 10, 13, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source0, 10, 13, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (source1, 10, 13, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay0, 10, 59, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (videorate, 10, 0, 64, GST_CLOCK_TIME_NONE); CHECK_OBJECT_PROPS_MAX (overlay1, 10, 51, 64, GST_CLOCK_TIME_NONE); _assert_rate_equal (videorate, "rate", 0.5, dval); gst_object_unref (timeline); g_value_unset (&fval); g_value_unset (&dval); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_children_properties_contain) { GESTimeline *timeline; GESLayer *layer; GESClip *clip; GList *tmp; GParamSpec **clips_child_props, **childrens_child_props = NULL; guint num_clips_props, num_childrens_props = 0; ges_init (); timeline = ges_timeline_new_audio_video (); layer = ges_timeline_append_layer (timeline); clip = GES_CLIP (ges_test_clip_new ()); assert_set_duration (clip, 50); fail_unless (ges_layer_add_clip (layer, clip)); clips_child_props = ges_timeline_element_list_children_properties (GES_TIMELINE_ELEMENT (clip), &num_clips_props); fail_unless (clips_child_props); fail_unless (num_clips_props); fail_unless (GES_CONTAINER_CHILDREN (clip)); for (tmp = GES_CONTAINER_CHILDREN (clip); tmp; tmp = tmp->next) childrens_child_props = append_children_properties (childrens_child_props, tmp->data, &num_childrens_props); assert_property_list_match (clips_child_props, num_clips_props, childrens_child_props, num_childrens_props); free_children_properties (clips_child_props, num_clips_props); free_children_properties (childrens_child_props, num_childrens_props); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; static gboolean _has_child_property (GESTimelineElement * element, GParamSpec * property) { gboolean has_prop = FALSE; guint num_props, i; GParamSpec **props = ges_timeline_element_list_children_properties (element, &num_props); for (i = 0; i < num_props; i++) { if (props[i] == property) has_prop = TRUE; g_param_spec_unref (props[i]); } g_free (props); return has_prop; } typedef struct { GstElement *child; GParamSpec *property; guint num_calls; } PropChangedData; #define _INIT_PROP_CHANGED_DATA(data) \ data.child = NULL; \ data.property = NULL; \ data.num_calls = 0; static void _prop_changed_cb (GESTimelineElement * element, GstElement * child, GParamSpec * property, PropChangedData * data) { data->num_calls++; data->property = property; data->child = child; } #define _assert_prop_changed_data(element, data, num_cmp, chld_cmp, prop_cmp) \ fail_unless (num_cmp == data.num_calls, \ "%s: num calls to callback (%u) not the expected %u", element->name, \ data.num_calls, num_cmp); \ fail_unless (prop_cmp == data.property, \ "%s: property %s is not the expected property %s", element->name, \ data.property->name, prop_cmp ? ((GParamSpec *)prop_cmp)->name : NULL); \ fail_unless (chld_cmp == data.child, \ "%s: child %s is not the expected child %s", element->name, \ GST_ELEMENT_NAME (data.child), \ chld_cmp ? GST_ELEMENT_NAME (chld_cmp) : NULL); #define _assert_int_val_child_prop(element, val, int_cmp, prop, prop_name) \ g_value_init (&val, G_TYPE_INT); \ ges_timeline_element_get_child_property_by_pspec (element, prop, &val); \ assert_equals_int (g_value_get_int (&val), int_cmp); \ g_value_unset (&val); \ g_value_init (&val, G_TYPE_INT); \ fail_unless (ges_timeline_element_get_child_property ( \ element, prop_name, &val)); \ assert_equals_int (g_value_get_int (&val), int_cmp); \ g_value_unset (&val); \ GST_START_TEST (test_children_properties_change) { GESTimeline *timeline; GESLayer *layer; GESTimelineElement *clip, *child; PropChangedData clip_add_data, clip_remove_data, clip_notify_data, child_add_data, child_remove_data, child_notify_data; GstElement *sub_child; GParamSpec *prop1, *prop2, *prop3; GValue val = G_VALUE_INIT; gint num_buffs; ges_init (); timeline = ges_timeline_new_audio_video (); layer = ges_timeline_append_layer (timeline); clip = GES_TIMELINE_ELEMENT (ges_test_clip_new ()); assert_set_duration (clip, 50); fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip))); fail_unless (GES_CONTAINER_CHILDREN (clip)); child = GES_CONTAINER_CHILDREN (clip)->data; /* fake sub-child */ sub_child = gst_element_factory_make ("fakesink", "sub-child"); fail_unless (sub_child); gst_object_ref_sink (sub_child); prop1 = g_object_class_find_property (G_OBJECT_GET_CLASS (sub_child), "num-buffers"); fail_unless (prop1); prop2 = g_object_class_find_property (G_OBJECT_GET_CLASS (sub_child), "dump"); fail_unless (prop2); prop3 = g_object_class_find_property (G_OBJECT_GET_CLASS (sub_child), "silent"); fail_unless (prop2); _INIT_PROP_CHANGED_DATA (clip_add_data); _INIT_PROP_CHANGED_DATA (clip_remove_data); _INIT_PROP_CHANGED_DATA (clip_notify_data); _INIT_PROP_CHANGED_DATA (child_add_data); _INIT_PROP_CHANGED_DATA (child_remove_data); _INIT_PROP_CHANGED_DATA (child_notify_data); g_signal_connect (clip, "child-property-added", G_CALLBACK (_prop_changed_cb), &clip_add_data); g_signal_connect (clip, "child-property-removed", G_CALLBACK (_prop_changed_cb), &clip_remove_data); g_signal_connect (clip, "deep-notify", G_CALLBACK (_prop_changed_cb), &clip_notify_data); g_signal_connect (child, "child-property-added", G_CALLBACK (_prop_changed_cb), &child_add_data); g_signal_connect (child, "child-property-removed", G_CALLBACK (_prop_changed_cb), &child_remove_data); g_signal_connect (child, "deep-notify", G_CALLBACK (_prop_changed_cb), &child_notify_data); /* adding to child should also add it to the parent clip */ fail_unless (ges_timeline_element_add_child_property (child, prop1, G_OBJECT (sub_child))); fail_unless (_has_child_property (child, prop1)); fail_unless (_has_child_property (clip, prop1)); _assert_prop_changed_data (clip, clip_add_data, 1, sub_child, prop1); _assert_prop_changed_data (clip, clip_remove_data, 0, NULL, NULL); _assert_prop_changed_data (clip, clip_notify_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_add_data, 1, sub_child, prop1); _assert_prop_changed_data (child, child_remove_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_notify_data, 0, NULL, NULL); fail_unless (ges_timeline_element_add_child_property (child, prop2, G_OBJECT (sub_child))); fail_unless (_has_child_property (child, prop2)); fail_unless (_has_child_property (clip, prop2)); _assert_prop_changed_data (clip, clip_add_data, 2, sub_child, prop2); _assert_prop_changed_data (clip, clip_remove_data, 0, NULL, NULL); _assert_prop_changed_data (clip, clip_notify_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_notify_data, 0, NULL, NULL); /* adding to parent does not add to the child */ fail_unless (ges_timeline_element_add_child_property (clip, prop3, G_OBJECT (sub_child))); fail_if (_has_child_property (child, prop3)); fail_unless (_has_child_property (clip, prop3)); _assert_prop_changed_data (clip, clip_add_data, 3, sub_child, prop3); _assert_prop_changed_data (clip, clip_remove_data, 0, NULL, NULL); _assert_prop_changed_data (clip, clip_notify_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_notify_data, 0, NULL, NULL); /* both should be notified of a change in the value */ g_object_set (G_OBJECT (sub_child), "num-buffers", 100, NULL); _assert_prop_changed_data (clip, clip_add_data, 3, sub_child, prop3); _assert_prop_changed_data (clip, clip_remove_data, 0, NULL, NULL); _assert_prop_changed_data (clip, clip_notify_data, 1, sub_child, prop1); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_notify_data, 1, sub_child, prop1); _assert_int_val_child_prop (clip, val, 100, prop1, "GstFakeSink::num-buffers"); _assert_int_val_child_prop (child, val, 100, prop1, "GstFakeSink::num-buffers"); g_value_init (&val, G_TYPE_INT); g_value_set_int (&val, 79); ges_timeline_element_set_child_property_by_pspec (clip, prop1, &val); g_value_unset (&val); _assert_prop_changed_data (clip, clip_add_data, 3, sub_child, prop3); _assert_prop_changed_data (clip, clip_remove_data, 0, NULL, NULL); _assert_prop_changed_data (clip, clip_notify_data, 2, sub_child, prop1); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_notify_data, 2, sub_child, prop1); _assert_int_val_child_prop (clip, val, 79, prop1, "GstFakeSink::num-buffers"); _assert_int_val_child_prop (child, val, 79, prop1, "GstFakeSink::num-buffers"); g_object_get (G_OBJECT (sub_child), "num-buffers", &num_buffs, NULL); assert_equals_int (num_buffs, 79); g_value_init (&val, G_TYPE_INT); g_value_set_int (&val, 97); fail_unless (ges_timeline_element_set_child_property (child, "GstFakeSink::num-buffers", &val)); g_value_unset (&val); _assert_prop_changed_data (clip, clip_add_data, 3, sub_child, prop3); _assert_prop_changed_data (clip, clip_remove_data, 0, NULL, NULL); _assert_prop_changed_data (clip, clip_notify_data, 3, sub_child, prop1); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 0, NULL, NULL); _assert_prop_changed_data (child, child_notify_data, 3, sub_child, prop1); _assert_int_val_child_prop (clip, val, 97, prop1, "GstFakeSink::num-buffers"); _assert_int_val_child_prop (child, val, 97, prop1, "GstFakeSink::num-buffers"); g_object_get (G_OBJECT (sub_child), "num-buffers", &num_buffs, NULL); assert_equals_int (num_buffs, 97); /* remove a property from the child, removes from the parent */ fail_unless (ges_timeline_element_remove_child_property (child, prop2)); _assert_prop_changed_data (clip, clip_add_data, 3, sub_child, prop3); _assert_prop_changed_data (clip, clip_remove_data, 1, sub_child, prop2); _assert_prop_changed_data (clip, clip_notify_data, 3, sub_child, prop1); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 1, sub_child, prop2); _assert_prop_changed_data (child, child_notify_data, 3, sub_child, prop1); fail_if (_has_child_property (child, prop2)); fail_if (_has_child_property (clip, prop2)); /* removing from parent doesn't remove from child */ fail_unless (ges_timeline_element_remove_child_property (clip, prop1)); _assert_prop_changed_data (clip, clip_add_data, 3, sub_child, prop3); _assert_prop_changed_data (clip, clip_remove_data, 2, sub_child, prop1); _assert_prop_changed_data (clip, clip_notify_data, 3, sub_child, prop1); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 1, sub_child, prop2); _assert_prop_changed_data (child, child_notify_data, 3, sub_child, prop1); fail_unless (_has_child_property (child, prop1)); fail_if (_has_child_property (clip, prop1)); /* but still safe to remove it from the child later */ fail_unless (ges_timeline_element_remove_child_property (child, prop1)); _assert_prop_changed_data (clip, clip_add_data, 3, sub_child, prop3); _assert_prop_changed_data (clip, clip_remove_data, 2, sub_child, prop1); _assert_prop_changed_data (clip, clip_notify_data, 3, sub_child, prop1); _assert_prop_changed_data (child, child_add_data, 2, sub_child, prop2); _assert_prop_changed_data (child, child_remove_data, 2, sub_child, prop1); _assert_prop_changed_data (child, child_notify_data, 3, sub_child, prop1); fail_if (_has_child_property (child, prop1)); fail_if (_has_child_property (clip, prop1)); gst_object_unref (sub_child); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; static GESTimelineElement * _el_with_child_prop (GESTimelineElement * clip, GObject * prop_child, GParamSpec * prop) { GList *tmp; GESTimelineElement *child = NULL; for (tmp = GES_CONTAINER_CHILDREN (clip); tmp; tmp = tmp->next) { GObject *found_child; GParamSpec *found_prop; if (ges_timeline_element_lookup_child (tmp->data, prop->name, &found_child, &found_prop)) { if (found_child == prop_child && found_prop == prop) { g_param_spec_unref (found_prop); g_object_unref (found_child); child = tmp->data; break; } g_param_spec_unref (found_prop); g_object_unref (found_child); } } return child; } static GstTimedValue * _new_timed_value (GstClockTime time, gdouble val) { GstTimedValue *tmval = g_new0 (GstTimedValue, 1); tmval->value = val; tmval->timestamp = time; return tmval; } #define _assert_binding(element, prop_name, child, timed_vals, mode) \ { \ GstInterpolationMode found_mode; \ GSList *tmp1; \ GList *tmp2; \ guint i; \ GList *found_timed_vals; \ GObject *found_object = NULL; \ GstControlSource *source = NULL; \ GstControlBinding *binding = ges_track_element_get_control_binding ( \ GES_TRACK_ELEMENT (element), prop_name); \ fail_unless (binding, "No control binding found for %s on %s", \ prop_name, GES_TIMELINE_ELEMENT_NAME (element)); \ g_object_get (G_OBJECT (binding), "control-source", &source, \ "object", &found_object, NULL); \ \ if (child) \ fail_unless (found_object == child); \ g_object_unref (found_object); \ \ fail_unless (GST_IS_INTERPOLATION_CONTROL_SOURCE (source)); \ found_timed_vals = gst_timed_value_control_source_get_all ( \ GST_TIMED_VALUE_CONTROL_SOURCE (source)); \ \ for (i = 0, tmp1 = timed_vals, tmp2 = found_timed_vals; tmp1 && tmp2; \ tmp1 = tmp1->next, tmp2 = tmp2->next, i++) { \ GstTimedValue *val1 = tmp1->data, *val2 = tmp2->data; \ gdouble diff = (val1->value > val2->value) ? \ val1->value - val2->value : val2->value - val1->value; \ fail_unless (val1->timestamp == val2->timestamp && diff < 0.0001, \ "The %ith timed value (%lu: %g) does not match the found timed " \ "value (%lu: %g)", i, val1->timestamp, val1->value, \ val2->timestamp, val2->value); \ } \ fail_unless (tmp1 == NULL, "Found too few timed values"); \ fail_unless (tmp2 == NULL, "Found too many timed values"); \ \ g_list_free (found_timed_vals); \ g_object_get (G_OBJECT (source), "mode", &found_mode, NULL); \ fail_unless (found_mode == mode); \ g_object_unref (source); \ } GST_START_TEST (test_copy_paste_children_properties) { GESTimeline *timeline; GESLayer *layer; GESTimelineElement *clip, *copy, *pasted, *track_el, *pasted_el; GObject *sub_child, *pasted_sub_child; GParamSpec **orig_props; guint num_orig_props; GParamSpec *prop, *found_prop; GValue val = G_VALUE_INIT; GstControlSource *source; GSList *timed_vals; ges_init (); timeline = ges_timeline_new_audio_video (); layer = ges_timeline_append_layer (timeline); clip = GES_TIMELINE_ELEMENT (ges_source_clip_new_time_overlay ()); assert_set_duration (clip, 50); fail_unless (ges_layer_add_clip (layer, GES_CLIP (clip))); /* get children properties */ orig_props = ges_timeline_element_list_children_properties (clip, &num_orig_props); fail_unless (num_orig_props); /* font-desc is originally "", but on setting switches to Normal, so we * set it explicitly */ ges_timeline_element_set_child_properties (clip, "font-desc", "Normal", "posx", 30, "posy", 50, "alpha", 0.1, "freq", 449.0, NULL); /* focus on one property */ fail_unless (ges_timeline_element_lookup_child (clip, "posx", &sub_child, &prop)); _assert_int_val_child_prop (clip, val, 30, prop, "posx"); /* find the track element where the child property comes from */ fail_unless (track_el = _el_with_child_prop (clip, sub_child, prop)); _assert_int_val_child_prop (track_el, val, 30, prop, "posx"); ges_track_element_set_auto_clamp_control_sources (GES_TRACK_ELEMENT (track_el), FALSE); /* set a control binding */ timed_vals = g_slist_prepend (NULL, _new_timed_value (200, 5)); timed_vals = g_slist_prepend (timed_vals, _new_timed_value (40, 50)); timed_vals = g_slist_prepend (timed_vals, _new_timed_value (20, 10)); timed_vals = g_slist_prepend (timed_vals, _new_timed_value (0, 20)); source = GST_CONTROL_SOURCE (gst_interpolation_control_source_new ()); g_object_set (G_OBJECT (source), "mode", GST_INTERPOLATION_MODE_CUBIC, NULL); fail_unless (gst_timed_value_control_source_set_from_list (GST_TIMED_VALUE_CONTROL_SOURCE (source), timed_vals)); fail_unless (ges_track_element_set_control_source (GES_TRACK_ELEMENT (track_el), source, "posx", "direct-absolute")); g_object_unref (source); /* check the control binding */ _assert_binding (track_el, "posx", sub_child, timed_vals, GST_INTERPOLATION_MODE_CUBIC); /* copy and paste */ fail_unless (copy = ges_timeline_element_copy (clip, TRUE)); fail_unless (pasted = ges_timeline_element_paste (copy, 30)); gst_object_unref (copy); gst_object_unref (pasted); /* test that the new clip has the same child properties */ assert_equal_children_properties (clip, pasted); /* get the details for the copied 'prop' property */ fail_unless (ges_timeline_element_lookup_child (pasted, "posx", &pasted_sub_child, &found_prop)); fail_unless (found_prop == prop); g_param_spec_unref (found_prop); fail_unless (G_OBJECT_TYPE (pasted_sub_child) == G_OBJECT_TYPE (sub_child)); _assert_int_val_child_prop (pasted, val, 30, prop, "posx"); /* get the associated child */ fail_unless (pasted_el = _el_with_child_prop (pasted, pasted_sub_child, prop)); _assert_int_val_child_prop (pasted_el, val, 30, prop, "posx"); assert_equal_children_properties (track_el, pasted_el); /* check the control binding on the pasted element */ _assert_binding (pasted_el, "posx", pasted_sub_child, timed_vals, GST_INTERPOLATION_MODE_CUBIC); assert_equal_bindings (pasted_el, track_el); /* free */ g_slist_free_full (timed_vals, g_free); free_children_properties (orig_props, num_orig_props); g_param_spec_unref (prop); g_object_unref (pasted_sub_child); g_object_unref (sub_child); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; #define _THREE_TIMED_VALS(timed_vals, tm1, val1, tm2, val2, tm3, val3) \ if (timed_vals) \ g_slist_free_full (timed_vals, g_free); \ timed_vals = g_slist_prepend (NULL, _new_timed_value (tm3, val3)); \ timed_vals = g_slist_prepend (timed_vals, _new_timed_value (tm2, val2)); \ timed_vals = g_slist_prepend (timed_vals, _new_timed_value (tm1, val1)); #define _TWO_TIMED_VALS(timed_vals, tm1, val1, tm2, val2) \ if (timed_vals) \ g_slist_free_full (timed_vals, g_free); \ timed_vals = g_slist_prepend (NULL, _new_timed_value (tm2, val2)); \ timed_vals = g_slist_prepend (timed_vals, _new_timed_value (tm1, val1)); #define _assert_control_source(obj, prop, vals) \ _assert_binding (obj, prop, NULL, vals, GST_INTERPOLATION_MODE_LINEAR); GST_START_TEST (test_children_property_bindings_with_rate_effects) { GESTimeline *timeline; GESTrack *track; GESLayer *layer; GESClip *clip; GESTrackElement *video_source, *rate0, *rate1, *overlay; GstControlSource *ctrl_source; GSList *video_source_vals = NULL, *overlay_vals = NULL; GValue value = G_VALUE_INIT; GstControlBinding *binding; ges_init (); g_value_init (&value, G_TYPE_DOUBLE); timeline = ges_timeline_new (); track = GES_TRACK (ges_video_track_new ()); fail_unless (ges_timeline_add_track (timeline, track)); layer = ges_timeline_append_layer (timeline); clip = GES_CLIP (ges_test_clip_new ()); assert_set_duration (clip, 4); assert_set_start (clip, 20); assert_set_inpoint (clip, 3); fail_unless (ges_layer_add_clip (layer, clip)); video_source = ges_clip_find_track_element (clip, track, GES_TYPE_SOURCE); fail_unless (video_source); gst_object_unref (video_source); rate0 = GES_TRACK_ELEMENT (ges_effect_new ("videorate rate=0.5")); rate1 = GES_TRACK_ELEMENT (ges_effect_new ("videorate rate=4.0")); overlay = GES_TRACK_ELEMENT (ges_effect_new ("textoverlay")); ges_track_element_set_has_internal_source (overlay, TRUE); assert_set_inpoint (overlay, 9); fail_unless (ges_clip_add_top_effect (clip, GES_BASE_EFFECT (rate0), -1, NULL)); fail_unless (ges_clip_add_top_effect (clip, GES_BASE_EFFECT (overlay), 0, NULL)); fail_unless (ges_clip_add_top_effect (clip, GES_BASE_EFFECT (rate1), 0, NULL)); fail_unless (ges_track_element_get_auto_clamp_control_sources (video_source)); fail_unless (ges_track_element_get_auto_clamp_control_sources (overlay)); /* source's alpha property */ _THREE_TIMED_VALS (video_source_vals, 1, 0.7, 7, 1.0, 15, 0.2); ctrl_source = GST_CONTROL_SOURCE (gst_interpolation_control_source_new ()); g_object_set (G_OBJECT (ctrl_source), "mode", GST_INTERPOLATION_MODE_LINEAR, NULL); fail_unless (gst_timed_value_control_source_set_from_list (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), video_source_vals)); fail_unless (ges_track_element_set_control_source (video_source, ctrl_source, "alpha", "direct")); gst_object_unref (ctrl_source); /* values have been clamped between its in-point:3 and its * out-point:11 (4ns in timeline is 8ns in source) */ _THREE_TIMED_VALS (video_source_vals, 3, 0.8, 7, 1.0, 11, 0.6); _assert_control_source (video_source, "alpha", video_source_vals); /* overlay's xpos property */ _THREE_TIMED_VALS (overlay_vals, 9, 12, 17, 16, 25, 8); ctrl_source = GST_CONTROL_SOURCE (gst_interpolation_control_source_new ()); g_object_set (G_OBJECT (ctrl_source), "mode", GST_INTERPOLATION_MODE_LINEAR, NULL); fail_unless (gst_timed_value_control_source_set_from_list (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), overlay_vals)); fail_unless (ges_track_element_set_control_source (overlay, ctrl_source, "xpos", "direct-absolute")); gst_object_unref (ctrl_source); /* unchanged since values are at the edges already * in-point:9 out-point:25 (4ns in timeline is 16ns in source) */ _assert_control_source (overlay, "xpos", overlay_vals); /* setting the in-point changes the in-point and out-point */ /* increase in-point */ assert_set_inpoint (video_source, 5); _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 13, 0.4); _assert_control_source (video_source, "alpha", video_source_vals); /* decrease in-point */ assert_set_inpoint (overlay, 7); _THREE_TIMED_VALS (overlay_vals, 7, 11, 17, 16, 23, 10); _assert_control_source (overlay, "xpos", overlay_vals); /* when trimming start, out-point should stay the same */ fail_unless (ges_timeline_element_edit_full (GES_TIMELINE_ELEMENT (clip), -1, GES_EDIT_MODE_TRIM, GES_EDGE_START, 19, NULL)); /* in-point of video_source now 3 */ _THREE_TIMED_VALS (video_source_vals, 3, 0.8, 7, 1.0, 13, 0.4); _assert_control_source (video_source, "alpha", video_source_vals); /* in-point of video_source now 3 */ _THREE_TIMED_VALS (overlay_vals, 3, 9, 17, 16, 23, 10); _assert_control_source (overlay, "xpos", overlay_vals); /* trim forwards */ fail_unless (ges_timeline_element_edit_full (GES_TIMELINE_ELEMENT (clip), -1, GES_EDIT_MODE_TRIM, GES_EDGE_START, 20, NULL)); /* in-point of video_source now 5 again */ _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 13, 0.4); _assert_control_source (video_source, "alpha", video_source_vals); /* in-point of overlay now 7 again */ _THREE_TIMED_VALS (overlay_vals, 7, 11, 17, 16, 23, 10); _assert_control_source (overlay, "xpos", overlay_vals); /* trim end */ fail_unless (ges_timeline_element_edit_full (GES_TIMELINE_ELEMENT (clip), -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, 25, NULL)); /* out-point of video_source now 15 */ _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 15, 0.2); _assert_control_source (video_source, "alpha", video_source_vals); /* out-point of overlay now 27 */ _THREE_TIMED_VALS (overlay_vals, 7, 11, 17, 16, 27, 6); _assert_control_source (overlay, "xpos", overlay_vals); /* trim backwards */ fail_unless (ges_timeline_element_edit_full (GES_TIMELINE_ELEMENT (clip), -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, 23, NULL)); /* out-point of video_source now 11 */ _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 11, 0.6); _assert_control_source (video_source, "alpha", video_source_vals); /* in-point of overlay now 19 */ _THREE_TIMED_VALS (overlay_vals, 7, 11, 17, 16, 19, 14); _assert_control_source (overlay, "xpos", overlay_vals); /* changing the rate changes the out-point */ _assert_set_rate (rate0, "rate", 1.0, value); /* out-point of video_source now 17 */ _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 17, 0.0); _assert_control_source (video_source, "alpha", video_source_vals); /* unchanged for overlay, which is after rate0 */ _assert_control_source (overlay, "xpos", overlay_vals); /* change back */ _assert_set_rate (rate0, "rate", 0.5, value); _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 11, 0.6); _assert_control_source (video_source, "alpha", video_source_vals); /* unchanged for overlay, which is after rate0 */ _assert_control_source (overlay, "xpos", overlay_vals); /* make inactive */ fail_unless (ges_track_element_set_active (rate0, FALSE)); _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 17, 0.0); _assert_control_source (video_source, "alpha", video_source_vals); /* unchanged for overlay, which is after rate0 */ _assert_control_source (overlay, "xpos", overlay_vals); /* make active again */ fail_unless (ges_track_element_set_active (rate0, TRUE)); _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 11, 0.6); _assert_control_source (video_source, "alpha", video_source_vals); /* unchanged for overlay, which is after rate0 */ _assert_control_source (overlay, "xpos", overlay_vals); /* change order */ fail_unless (ges_clip_set_top_effect_index (clip, GES_BASE_EFFECT (overlay), 2)); /* video source unchanged */ _assert_control_source (video_source, "alpha", video_source_vals); /* new out-point is 13 * new value is interpolated between the previous value * (at time 7, value 11) and the *final* value (at time 19, value 14) * Not the middle value at time 17, value 16! */ _TWO_TIMED_VALS (overlay_vals, 7, 11, 13, 12.5); _assert_control_source (overlay, "xpos", overlay_vals); /* removing time effect changes out-point */ gst_object_ref (rate0); fail_unless (ges_clip_remove_top_effect (clip, GES_BASE_EFFECT (rate0), NULL)); _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 17, 0.0); _assert_control_source (video_source, "alpha", video_source_vals); _TWO_TIMED_VALS (overlay_vals, 7, 11, 19, 14); _assert_control_source (overlay, "xpos", overlay_vals); /* adding also changes it */ fail_unless (ges_clip_add_top_effect (clip, GES_BASE_EFFECT (rate0), 2, NULL)); _THREE_TIMED_VALS (video_source_vals, 5, 0.9, 7, 1.0, 11, 0.6); _assert_control_source (video_source, "alpha", video_source_vals); /* unchanged for overlay */ _assert_control_source (overlay, "xpos", overlay_vals); /* new value will use the value already set at in-point if possible */ assert_set_inpoint (video_source, 7); _TWO_TIMED_VALS (video_source_vals, 7, 1.0, 13, 0.4); _assert_control_source (video_source, "alpha", video_source_vals); /* same with out-point for overlay */ binding = ges_track_element_get_control_binding (overlay, "xpos"); fail_unless (binding); g_object_get (binding, "control-source", &ctrl_source, NULL); fail_unless (gst_timed_value_control_source_set (GST_TIMED_VALUE_CONTROL_SOURCE (ctrl_source), 11, 5)); gst_object_unref (ctrl_source); _THREE_TIMED_VALS (overlay_vals, 7, 11, 11, 5, 19, 14); _assert_control_source (overlay, "xpos", overlay_vals); fail_unless (ges_timeline_element_edit_full (GES_TIMELINE_ELEMENT (clip), -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, 21, NULL)); _TWO_TIMED_VALS (video_source_vals, 7, 1.0, 9, 0.8); _assert_control_source (video_source, "alpha", video_source_vals); /* overlay uses existing value, rather than an interpolation */ _TWO_TIMED_VALS (overlay_vals, 7, 11, 11, 5); _assert_control_source (overlay, "xpos", overlay_vals); g_slist_free_full (video_source_vals, g_free); g_slist_free_full (overlay_vals, g_free); gst_object_unref (timeline); g_value_unset (&value); ges_deinit (); } GST_END_TEST; GST_START_TEST (test_unchanged_after_layer_add_failure) { GList *found; GESTrack *track; GESTimeline *timeline; GESLayer *layer; GESClip *clip0, *clip1; GESTimelineElement *effect, *source; ges_init (); timeline = ges_timeline_new (); layer = ges_timeline_append_layer (timeline); /* two video tracks */ track = GES_TRACK (ges_video_track_new ()); fail_unless (ges_timeline_add_track (timeline, track)); track = GES_TRACK (ges_video_track_new ()); fail_unless (ges_timeline_add_track (timeline, track)); clip0 = GES_CLIP (ges_test_clip_new ()); clip1 = GES_CLIP (ges_test_clip_new ()); gst_object_ref (clip0); gst_object_ref (clip1); assert_set_start (clip0, 0); assert_set_duration (clip0, 10); assert_set_start (clip1, 0); assert_set_duration (clip1, 10); effect = GES_TIMELINE_ELEMENT (ges_effect_new ("agingtv")); _assert_add (clip1, effect); assert_num_children (clip0, 0); assert_num_children (clip1, 1); fail_unless (ges_layer_add_clip (layer, clip0)); assert_num_children (clip0, 2); assert_num_children (clip1, 1); fail_unless (GES_CONTAINER_CHILDREN (clip1)->data == effect); /* addition should fail since sources would fully overlap */ fail_if (ges_layer_add_clip (layer, clip1)); /* children should be the same */ assert_num_children (clip0, 2); assert_num_children (clip1, 1); fail_unless (GES_CONTAINER_CHILDREN (clip1)->data == effect); /* should be able to add again once we have fixed the problem */ fail_unless (ges_layer_remove_clip (layer, clip0)); assert_num_children (clip0, 2); assert_num_children (clip1, 1); fail_unless (ges_layer_add_clip (layer, clip1)); assert_num_children (clip0, 2); /* now has two sources and two effects */ assert_num_children (clip1, 4); found = ges_clip_find_track_elements (clip1, NULL, GES_TRACK_TYPE_VIDEO, GES_TYPE_VIDEO_SOURCE); fail_unless_equals_int (g_list_length (found), 2); g_list_free_full (found, gst_object_unref); found = ges_clip_find_track_elements (clip1, NULL, GES_TRACK_TYPE_VIDEO, GES_TYPE_EFFECT); fail_unless_equals_int (g_list_length (found), 2); g_list_free_full (found, gst_object_unref); /* similarly cannot add clip0 back, and children should not change */ /* remove the extra source */ _assert_remove (clip0, GES_CONTAINER_CHILDREN (clip0)->data); assert_num_children (clip0, 1); source = GES_CONTAINER_CHILDREN (clip0)->data; fail_if (ges_layer_add_clip (layer, clip0)); /* children should be the same */ assert_num_children (clip0, 1); assert_num_children (clip1, 4); fail_unless (GES_CONTAINER_CHILDREN (clip0)->data == source); gst_object_unref (clip0); gst_object_unref (clip1); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; #define _assert_timeline_to_internal(clip, child, in, expect_out) \ {\ GError *error = NULL; \ GstClockTime found = ges_clip_get_internal_time_from_timeline_time ( \ clip, child, (in) * GST_SECOND, &error); \ GstClockTime expect = expect_out * GST_SECOND; \ fail_unless (found == expect, "Conversion from timeline time %" \ GST_TIME_FORMAT " to the internal time of %" GES_FORMAT " gave %" \ GST_TIME_FORMAT " rather than the expected %" GST_TIME_FORMAT \ " (error: %s)", GST_TIME_ARGS ((in) * GST_SECOND), \ GES_ARGS (child), GST_TIME_ARGS (found), GST_TIME_ARGS (expect), \ error ? error->message : "None"); \ fail_if (error); \ } #define _assert_timeline_to_internal_fails(clip, child, in, error_code) \ { \ GError *error = NULL; \ GstClockTime found = ges_clip_get_internal_time_from_timeline_time ( \ clip, child, (in) * GST_SECOND, &error); \ fail_if (GST_CLOCK_TIME_IS_VALID (found), "Conversion from timeline " \ "time %" GST_TIME_FORMAT " to the internal time of %" GES_FORMAT \ " successfully converted to %" GST_TIME_FORMAT " rather than " \ "GST_CLOCK_TIME_NONE", GST_TIME_ARGS ((in) * GST_SECOND), \ GES_ARGS (child), GST_TIME_ARGS (found)); \ assert_GESError (error, error_code); \ } #define _assert_internal_to_timeline(clip, child, in, expect_out) \ {\ GError *error = NULL; \ GstClockTime found = ges_clip_get_timeline_time_from_internal_time ( \ clip, child, (in) * GST_SECOND, &error); \ GstClockTime expect = expect_out * GST_SECOND; \ fail_unless (found == expect, "Conversion from the internal time %" \ GST_TIME_FORMAT " of %" GES_FORMAT " to the timeline time gave %" \ GST_TIME_FORMAT " rather than the expected %" GST_TIME_FORMAT, \ GST_TIME_ARGS ((in) * GST_SECOND), GES_ARGS (child), \ GST_TIME_ARGS (found), GST_TIME_ARGS (expect)); \ fail_if (error); \ } #define _assert_internal_to_timeline_fails(clip, child, in, error_code) \ {\ GError *error = NULL; \ GstClockTime found = ges_clip_get_timeline_time_from_internal_time ( \ clip, child, (in) * GST_SECOND, &error); \ fail_if (GST_CLOCK_TIME_IS_VALID (found), "Conversion from the " \ "internal time %" GST_TIME_FORMAT " of %" GES_FORMAT " to the " \ "timeline time gave %" GST_TIME_FORMAT " rather than " \ "GST_CLOCK_TIME_NONE", GST_TIME_ARGS ((in) * GST_SECOND), \ GES_ARGS (child), GST_TIME_ARGS (found)); \ assert_GESError (error, error_code); \ } #define _assert_frame_to_timeline(clip, frame, expect_out) \ {\ GError *error = NULL; \ GstClockTime found = ges_clip_get_timeline_time_from_source_frame ( \ clip, frame, &error); \ GstClockTime expect = expect_out * GST_SECOND; \ fail_unless (found == expect, "Conversion from the source frame %" \ G_GINT64_FORMAT " to the timeline time gave %" GST_TIME_FORMAT \ " rather than the expected %" GST_TIME_FORMAT, frame, \ GST_TIME_ARGS (found), GST_TIME_ARGS (expect)); \ fail_if (error); \ } #define _assert_frame_to_timeline_fails(clip, frame, error_code) \ {\ GError *error = NULL; \ GstClockTime found = ges_clip_get_timeline_time_from_source_frame ( \ clip, frame, &error); \ fail_if (GST_CLOCK_TIME_IS_VALID (found), "Conversion from the " \ "source frame %" G_GINT64_FORMAT " to the timeline time gave %" \ GST_TIME_FORMAT " rather than the expected GST_CLOCK_TIME_NONE", \ frame, GST_TIME_ARGS (found)); \ assert_GESError (error, error_code); \ } GST_START_TEST (test_convert_time) { GESTimeline *timeline; GESTrack *track0, *track1; GESAsset *asset; GESLayer *layer; GESClip *clip; GESTrackElement *source0, *source1, *rate0, *rate1, *rate2, *overlay; GValue val = G_VALUE_INIT; ges_init (); asset = ges_asset_request (GES_TYPE_TEST_CLIP, "framerate=30/1, max-duration=93.0", NULL); fail_unless (asset); timeline = ges_timeline_new (); track0 = GES_TRACK (ges_video_track_new ()); track1 = GES_TRACK (ges_video_track_new ()); fail_unless (ges_timeline_add_track (timeline, track0)); fail_unless (ges_timeline_add_track (timeline, track1)); layer = ges_timeline_append_layer (timeline); clip = ges_layer_add_asset (layer, asset, 20 * GST_SECOND, 13 * GST_SECOND, 10 * GST_SECOND, GES_TRACK_TYPE_VIDEO); fail_unless (clip); CHECK_OBJECT_PROPS_MAX (clip, 20 * GST_SECOND, 13 * GST_SECOND, 10 * GST_SECOND, 93 * GST_SECOND); source0 = ges_clip_find_track_element (clip, track0, GES_TYPE_VIDEO_TEST_SOURCE); source1 = ges_clip_find_track_element (clip, track1, GES_TYPE_VIDEO_TEST_SOURCE); rate0 = GES_TRACK_ELEMENT (ges_effect_new ("videorate")); rate1 = GES_TRACK_ELEMENT (ges_effect_new ("videorate")); rate2 = GES_TRACK_ELEMENT (ges_effect_new ("videorate")); overlay = GES_TRACK_ELEMENT (ges_effect_new ("textoverlay")); ges_track_element_set_has_internal_source (overlay, TRUE); /* enough internal content to last 10 seconds at a rate of 4.0 */ assert_set_inpoint (overlay, 7 * GST_SECOND); assert_set_max_duration (overlay, 50 * GST_SECOND); fail_unless (ges_track_add_element (track0, rate0)); fail_unless (ges_track_add_element (track1, rate1)); fail_unless (ges_track_add_element (track1, rate2)); fail_unless (ges_track_add_element (track1, overlay)); _assert_add (clip, rate0); _assert_add (clip, rate2); _assert_add (clip, overlay); _assert_add (clip, rate1); /* in track0: * * source0 -> rate0 -> out * * in track1: * * source1 -> rate1 -> overlay -> rate2 -> out */ g_value_init (&val, G_TYPE_DOUBLE); _assert_rate_equal (rate0, "rate", 1.0, val); _assert_rate_equal (rate1, "rate", 1.0, val); _assert_rate_equal (rate2, "rate", 1.0, val); /* without rates */ /* start of the clip */ _assert_internal_to_timeline (clip, source0, 13, 20); _assert_internal_to_timeline (clip, source1, 13, 20); _assert_internal_to_timeline (clip, overlay, 7, 20); _assert_frame_to_timeline (clip, 390, 20); _assert_timeline_to_internal (clip, source0, 20, 13); _assert_timeline_to_internal (clip, source1, 20, 13); _assert_timeline_to_internal (clip, overlay, 20, 7); /* middle of the clip */ _assert_internal_to_timeline (clip, source0, 18, 25); _assert_internal_to_timeline (clip, source1, 18, 25); _assert_internal_to_timeline (clip, overlay, 12, 25); _assert_frame_to_timeline (clip, 540, 25); _assert_timeline_to_internal (clip, source0, 25, 18); _assert_timeline_to_internal (clip, source1, 25, 18); _assert_timeline_to_internal (clip, overlay, 25, 12); /* end of the clip */ _assert_internal_to_timeline (clip, source0, 23, 30); _assert_internal_to_timeline (clip, source1, 23, 30); _assert_internal_to_timeline (clip, overlay, 17, 30); _assert_frame_to_timeline (clip, 690, 30); _assert_timeline_to_internal (clip, source0, 30, 23); _assert_timeline_to_internal (clip, source1, 30, 23); _assert_timeline_to_internal (clip, overlay, 30, 17); /* beyond the end of the clip */ /* exceeds the max-duration of the elements, but that is ok */ _assert_internal_to_timeline (clip, source0, 123, 130); _assert_internal_to_timeline (clip, source1, 123, 130); _assert_internal_to_timeline (clip, overlay, 117, 130); _assert_frame_to_timeline (clip, 3690, 130); _assert_timeline_to_internal (clip, source0, 130, 123); _assert_timeline_to_internal (clip, source1, 130, 123); _assert_timeline_to_internal (clip, overlay, 130, 117); /* before the start of the clip */ _assert_internal_to_timeline (clip, source0, 8, 15); _assert_internal_to_timeline (clip, source1, 8, 15); _assert_internal_to_timeline (clip, overlay, 2, 15); _assert_frame_to_timeline (clip, 240, 15); _assert_timeline_to_internal (clip, source0, 15, 8); _assert_timeline_to_internal (clip, source1, 15, 8); _assert_timeline_to_internal (clip, overlay, 15, 2); /* too early for overlay */ _assert_timeline_to_internal (clip, source0, 10, 3); _assert_timeline_to_internal (clip, source1, 10, 3); _assert_timeline_to_internal_fails (clip, overlay, 10, GES_ERROR_NEGATIVE_TIME); /* too early for sources */ _assert_timeline_to_internal_fails (clip, source0, 5, GES_ERROR_NEGATIVE_TIME); _assert_timeline_to_internal_fails (clip, source1, 5, GES_ERROR_NEGATIVE_TIME); _assert_timeline_to_internal_fails (clip, overlay, 5, GES_ERROR_NEGATIVE_TIME); assert_set_start (clip, 10 * GST_SECOND); /* too early in the timeline */ _assert_internal_to_timeline_fails (clip, source0, 2, GES_ERROR_NEGATIVE_TIME); _assert_internal_to_timeline_fails (clip, source1, 2, GES_ERROR_NEGATIVE_TIME); _assert_internal_to_timeline (clip, overlay, 2, 5); _assert_frame_to_timeline_fails (clip, 60, GES_ERROR_INVALID_FRAME_NUMBER); assert_set_start (clip, 6 * GST_SECOND); _assert_internal_to_timeline_fails (clip, source0, 6, GES_ERROR_NEGATIVE_TIME); _assert_internal_to_timeline_fails (clip, source1, 6, GES_ERROR_NEGATIVE_TIME); _assert_internal_to_timeline_fails (clip, overlay, 0, GES_ERROR_NEGATIVE_TIME); _assert_frame_to_timeline_fails (clip, 180, GES_ERROR_INVALID_FRAME_NUMBER); assert_set_start (clip, 20 * GST_SECOND); /* now with rate effects * Note, they are currently out of sync */ _assert_set_rate (rate0, "rate", 0.5, val); _assert_set_rate (rate1, "rate", 2.0, val); _assert_set_rate (rate2, "rate", 4.0, val); CHECK_OBJECT_PROPS_MAX (clip, 20 * GST_SECOND, 13 * GST_SECOND, 10 * GST_SECOND, 93 * GST_SECOND); /* start of the clip is the same */ _assert_internal_to_timeline (clip, source0, 13, 20); _assert_internal_to_timeline (clip, source1, 13, 20); _assert_internal_to_timeline (clip, overlay, 7, 20); _assert_timeline_to_internal (clip, source0, 20, 13); _assert_timeline_to_internal (clip, source1, 20, 13); _assert_timeline_to_internal (clip, overlay, 20, 7); /* middle is different */ /* 5 seconds in the timeline is 2.5 seconds into the source */ _assert_internal_to_timeline (clip, source0, 15.5, 25); /* 5 seconds in the timeline is 40 seconds into the source */ _assert_internal_to_timeline (clip, source1, 53, 25); /* 5 seconds in the timeline is 20 seconds into the source */ _assert_internal_to_timeline (clip, overlay, 27, 25); /* reverse */ _assert_timeline_to_internal (clip, source0, 25, 15.5); _assert_timeline_to_internal (clip, source1, 25, 53); _assert_timeline_to_internal (clip, overlay, 25, 27); /* end is different */ _assert_internal_to_timeline (clip, source0, 18, 30); _assert_internal_to_timeline (clip, source1, 93, 30); _assert_internal_to_timeline (clip, overlay, 47, 30); _assert_timeline_to_internal (clip, source0, 30, 18); _assert_timeline_to_internal (clip, source1, 30, 93); _assert_timeline_to_internal (clip, overlay, 30, 47); /* beyond end is different */ _assert_internal_to_timeline (clip, source0, 68, 130); _assert_internal_to_timeline (clip, source1, 893, 130); _assert_internal_to_timeline (clip, overlay, 447, 130); _assert_timeline_to_internal (clip, source0, 130, 68); _assert_timeline_to_internal (clip, source1, 130, 893); _assert_timeline_to_internal (clip, overlay, 130, 447); /* before the start */ _assert_internal_to_timeline (clip, source0, 12.5, 19); _assert_internal_to_timeline (clip, source1, 5, 19); _assert_internal_to_timeline (clip, overlay, 3, 19); _assert_timeline_to_internal (clip, source0, 19, 12.5); _assert_timeline_to_internal (clip, source1, 19, 5); _assert_timeline_to_internal (clip, overlay, 19, 3); /* too early for source1 and overlay */ _assert_internal_to_timeline (clip, source0, 12, 18); _assert_timeline_to_internal (clip, source0, 18, 12); _assert_timeline_to_internal_fails (clip, source1, 18, GES_ERROR_NEGATIVE_TIME); _assert_timeline_to_internal_fails (clip, overlay, 18, GES_ERROR_NEGATIVE_TIME); assert_set_inpoint (overlay, 8 * GST_SECOND); /* now fine */ _assert_internal_to_timeline (clip, overlay, 0, 18); _assert_timeline_to_internal (clip, overlay, 18, 0); assert_set_inpoint (overlay, 7 * GST_SECOND); /* still not too early for source0 */ _assert_internal_to_timeline (clip, source0, 5.5, 5); _assert_timeline_to_internal (clip, source0, 5, 5.5); _assert_timeline_to_internal_fails (clip, source1, 5, GES_ERROR_NEGATIVE_TIME); _assert_timeline_to_internal_fails (clip, overlay, 5, GES_ERROR_NEGATIVE_TIME); _assert_internal_to_timeline (clip, source0, 3, 0); _assert_timeline_to_internal (clip, source0, 0, 3); _assert_timeline_to_internal_fails (clip, source1, 5, GES_ERROR_NEGATIVE_TIME); _assert_timeline_to_internal_fails (clip, overlay, 5, GES_ERROR_NEGATIVE_TIME); /* too early for the timeline */ _assert_internal_to_timeline_fails (clip, source0, 2, GES_ERROR_NEGATIVE_TIME); /* re-sync rates between tracks */ _assert_set_rate (rate2, "rate", 0.25, val); CHECK_OBJECT_PROPS_MAX (clip, 20 * GST_SECOND, 13 * GST_SECOND, 10 * GST_SECOND, 93 * GST_SECOND); /* start of the clip */ _assert_internal_to_timeline (clip, source0, 13, 20); _assert_internal_to_timeline (clip, source1, 13, 20); _assert_internal_to_timeline (clip, overlay, 7, 20); _assert_frame_to_timeline (clip, 390, 20); _assert_timeline_to_internal (clip, source0, 20, 13); _assert_timeline_to_internal (clip, source1, 20, 13); _assert_timeline_to_internal (clip, overlay, 20, 7); /* middle of the clip */ _assert_internal_to_timeline (clip, source0, 15.5, 25); _assert_internal_to_timeline (clip, source1, 15.5, 25); _assert_internal_to_timeline (clip, overlay, 8.25, 25); _assert_frame_to_timeline (clip, 465, 25); _assert_timeline_to_internal (clip, source0, 25, 15.5); _assert_timeline_to_internal (clip, source1, 25, 15.5); _assert_timeline_to_internal (clip, overlay, 25, 8.25); /* end of the clip */ _assert_internal_to_timeline (clip, source0, 18, 30); _assert_internal_to_timeline (clip, source1, 18, 30); _assert_internal_to_timeline (clip, overlay, 9.5, 30); _assert_frame_to_timeline (clip, 540, 30); _assert_timeline_to_internal (clip, source0, 30, 18); _assert_timeline_to_internal (clip, source1, 30, 18); _assert_timeline_to_internal (clip, overlay, 30, 9.5); /* beyond the end of the clip */ /* exceeds the max-duration of the elements, but that is ok */ _assert_internal_to_timeline (clip, source0, 68, 130); _assert_internal_to_timeline (clip, source1, 68, 130); _assert_internal_to_timeline (clip, overlay, 34.5, 130); _assert_frame_to_timeline (clip, 2040, 130); _assert_timeline_to_internal (clip, source0, 130, 68); _assert_timeline_to_internal (clip, source1, 130, 68); _assert_timeline_to_internal (clip, overlay, 130, 34.5); /* before the start of the clip */ _assert_internal_to_timeline (clip, source0, 10.5, 15); _assert_internal_to_timeline (clip, source1, 10.5, 15); _assert_internal_to_timeline (clip, overlay, 5.75, 15); _assert_frame_to_timeline (clip, 315, 15); _assert_timeline_to_internal (clip, source0, 15, 10.5); _assert_timeline_to_internal (clip, source1, 15, 10.5); _assert_timeline_to_internal (clip, overlay, 15, 5.75); /* not too early */ _assert_internal_to_timeline (clip, source0, 3, 0); _assert_internal_to_timeline (clip, source1, 3, 0); _assert_internal_to_timeline (clip, overlay, 2, 0); _assert_frame_to_timeline (clip, 90, 0); _assert_timeline_to_internal (clip, source0, 0, 3); _assert_timeline_to_internal (clip, source1, 0, 3); _assert_timeline_to_internal (clip, overlay, 0, 2); /* too early for timeline */ _assert_internal_to_timeline_fails (clip, source0, 2, GES_ERROR_NEGATIVE_TIME); _assert_internal_to_timeline_fails (clip, source1, 2, GES_ERROR_NEGATIVE_TIME); _assert_internal_to_timeline_fails (clip, overlay, 1, GES_ERROR_NEGATIVE_TIME); _assert_frame_to_timeline_fails (clip, 89, GES_ERROR_INVALID_FRAME_NUMBER); assert_set_start (clip, 30 * GST_SECOND); /* timeline times have shifted by 10 */ _assert_timeline_to_internal (clip, source0, 10, 3); _assert_timeline_to_internal (clip, source1, 10, 3); _assert_timeline_to_internal (clip, overlay, 10, 2); _assert_timeline_to_internal (clip, source0, 4, 0); _assert_timeline_to_internal (clip, source1, 4, 0); _assert_timeline_to_internal (clip, overlay, 2, 0); /* too early for internal */ _assert_timeline_to_internal_fails (clip, source0, 3, GES_ERROR_NEGATIVE_TIME); _assert_timeline_to_internal_fails (clip, source1, 3, GES_ERROR_NEGATIVE_TIME); _assert_timeline_to_internal_fails (clip, overlay, 1, GES_ERROR_NEGATIVE_TIME); g_value_unset (&val); gst_object_unref (asset); gst_object_unref (timeline); ges_deinit (); } GST_END_TEST; static Suite * ges_suite (void) { Suite *s = suite_create ("ges-clip"); TCase *tc_chain = tcase_create ("clip"); suite_add_tcase (s, tc_chain); tcase_add_test (tc_chain, test_object_properties); tcase_add_test (tc_chain, test_split_object); tcase_add_test (tc_chain, test_split_ordering); tcase_add_test (tc_chain, test_split_direct_bindings); tcase_add_test (tc_chain, test_split_direct_absolute_bindings); tcase_add_test (tc_chain, test_split_with_auto_transitions); tcase_add_test (tc_chain, test_clip_group_ungroup); tcase_add_test (tc_chain, test_clip_can_group); tcase_add_test (tc_chain, test_adding_children_to_track); tcase_add_test (tc_chain, test_clip_refcount_remove_child); tcase_add_test (tc_chain, test_clip_find_track_element); tcase_add_test (tc_chain, test_effects_priorities); tcase_add_test (tc_chain, test_children_time_setters); tcase_add_test (tc_chain, test_not_enough_internal_content_for_core); tcase_add_test (tc_chain, test_can_add_effect); tcase_add_test (tc_chain, test_children_active); tcase_add_test (tc_chain, test_children_inpoint); tcase_add_test (tc_chain, test_children_max_duration); tcase_add_test (tc_chain, test_duration_limit); tcase_add_test (tc_chain, test_can_set_duration_limit); tcase_add_test (tc_chain, test_rate_effects_duration_limit); tcase_add_test (tc_chain, test_children_properties_contain); tcase_add_test (tc_chain, test_children_properties_change); tcase_add_test (tc_chain, test_copy_paste_children_properties); tcase_add_test (tc_chain, test_children_property_bindings_with_rate_effects); tcase_add_test (tc_chain, test_unchanged_after_layer_add_failure); tcase_add_test (tc_chain, test_convert_time); return s; } GST_CHECK_MAIN (ges);