mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-13 03:46:34 +00:00
755 lines
24 KiB
C
755 lines
24 KiB
C
/* GStreamer Editing Services
|
|
*
|
|
* Copyright (C) 2012 Volodymyr Rudyi <vladimir.rudoy@gmail.com>
|
|
* Copyright (C) 2015 Thibault Saunier <tsaunier@gnome.org>
|
|
*
|
|
* 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., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "test-utils.h"
|
|
/* #include "../../../ges/ges-internal.h" */
|
|
#include <ges/ges.h>
|
|
#include <gst/check/gstcheck.h>
|
|
|
|
static GMainLoop *mainloop;
|
|
|
|
static void
|
|
source_asset_created (GObject * source, GAsyncResult * res,
|
|
gpointer expected_ok)
|
|
{
|
|
GError *error = NULL;
|
|
|
|
GESAsset *a = ges_asset_request_finish (res, &error);
|
|
|
|
if (GPOINTER_TO_INT (expected_ok)) {
|
|
fail_unless (a != NULL);
|
|
fail_unless (error == NULL);
|
|
g_object_unref (a);
|
|
} else {
|
|
fail_unless (a == NULL);
|
|
assert_equals_int (error->domain, GST_RESOURCE_ERROR);
|
|
}
|
|
|
|
g_clear_error (&error);
|
|
g_main_loop_quit (mainloop);
|
|
}
|
|
|
|
GST_START_TEST (test_basic)
|
|
{
|
|
ges_init ();
|
|
|
|
mainloop = g_main_loop_new (NULL, FALSE);
|
|
ges_asset_request_async (GES_TYPE_URI_CLIP,
|
|
"file:///this/is/not/for/real", NULL, source_asset_created,
|
|
GINT_TO_POINTER (FALSE));
|
|
|
|
g_main_loop_run (mainloop);
|
|
g_main_loop_unref (mainloop);
|
|
ges_deinit ();
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
typedef struct _CustomContextData
|
|
{
|
|
GMutex lock;
|
|
GCond cond;
|
|
gboolean finish;
|
|
gboolean expected_ok;
|
|
gchar *uri;
|
|
} CustomContextData;
|
|
|
|
static gpointer
|
|
custom_context_thread_func (CustomContextData * data)
|
|
{
|
|
GMainContext *context;
|
|
|
|
context = g_main_context_new ();
|
|
mainloop = g_main_loop_new (context, FALSE);
|
|
|
|
g_main_context_push_thread_default (context);
|
|
|
|
/* To use custom context, we need to call ges_init() in the thread */
|
|
fail_unless (ges_init ());
|
|
|
|
ges_asset_request_async (GES_TYPE_URI_CLIP,
|
|
data->uri, NULL, source_asset_created,
|
|
GINT_TO_POINTER (data->expected_ok));
|
|
g_main_loop_run (mainloop);
|
|
|
|
g_main_context_pop_thread_default (context);
|
|
ges_deinit ();
|
|
g_main_context_unref (context);
|
|
g_main_loop_unref (mainloop);
|
|
|
|
data->finish = TRUE;
|
|
g_cond_signal (&data->cond);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
GST_START_TEST (test_custom_context)
|
|
{
|
|
GThread *thread;
|
|
CustomContextData data;
|
|
|
|
mainloop = NULL;
|
|
|
|
g_mutex_init (&data.lock);
|
|
g_cond_init (&data.cond);
|
|
/* ensure default context here, but we will not use the default context */
|
|
g_main_context_default ();
|
|
|
|
/* first run with invalid uri */
|
|
data.finish = FALSE;
|
|
data.expected_ok = FALSE;
|
|
data.uri = g_strdup ("file:///this/is/not/for/real");
|
|
|
|
thread = g_thread_new ("test-custom-context-thread",
|
|
(GThreadFunc) custom_context_thread_func, &data);
|
|
|
|
g_mutex_lock (&data.lock);
|
|
while (data.finish)
|
|
g_cond_wait (&data.cond, &data.lock);
|
|
g_mutex_unlock (&data.lock);
|
|
|
|
g_thread_join (thread);
|
|
g_free (data.uri);
|
|
|
|
/* second run with valid uri */
|
|
data.finish = FALSE;
|
|
data.expected_ok = TRUE;
|
|
data.uri = ges_test_file_uri ("audio_video.ogg");
|
|
|
|
thread = g_thread_new ("test-custom-context-thread",
|
|
(GThreadFunc) custom_context_thread_func, &data);
|
|
|
|
g_mutex_lock (&data.lock);
|
|
while (data.finish)
|
|
g_cond_wait (&data.cond, &data.lock);
|
|
g_mutex_unlock (&data.lock);
|
|
|
|
g_thread_join (thread);
|
|
g_free (data.uri);
|
|
|
|
g_mutex_clear (&data.lock);
|
|
g_cond_clear (&data.cond);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_transition_change_asset)
|
|
{
|
|
gchar *id;
|
|
GESAsset *a;
|
|
GESExtractable *extractable;
|
|
|
|
ges_init ();
|
|
|
|
a = ges_asset_request (GES_TYPE_TRANSITION_CLIP, "box-wipe-lc", NULL);
|
|
|
|
fail_unless (GES_IS_ASSET (a));
|
|
fail_unless_equals_string (ges_asset_get_id (a), "box-wipe-lc");
|
|
|
|
extractable = ges_asset_extract (a, NULL);
|
|
fail_unless (ges_extractable_get_asset (extractable) == a);
|
|
|
|
id = ges_extractable_get_id (extractable);
|
|
fail_unless_equals_string (id, "box-wipe-lc");
|
|
g_free (id);
|
|
|
|
g_object_set (extractable, "vtype", 2, NULL);
|
|
|
|
id = ges_extractable_get_id (extractable);
|
|
fail_unless_equals_string (id, "bar-wipe-tb");
|
|
g_free (id);
|
|
|
|
fail_if (ges_extractable_get_asset (extractable) == a);
|
|
gst_object_unref (a);
|
|
|
|
a = ges_extractable_get_asset (extractable);
|
|
fail_unless_equals_string (ges_asset_get_id (a), "bar-wipe-tb");
|
|
|
|
/* Now try to set the a and see if the vtype is properly updated */
|
|
a = ges_asset_request (GES_TYPE_TRANSITION_CLIP, "box-wipe-lc", NULL);
|
|
ges_extractable_set_asset (extractable, a);
|
|
gst_object_unref (a);
|
|
|
|
fail_unless_equals_int (GES_TRANSITION_CLIP (extractable)->vtype, 26);
|
|
|
|
gst_object_unref (extractable);
|
|
ges_deinit ();
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_uri_clip_change_asset)
|
|
{
|
|
GESAsset *asset, *asset1;
|
|
GESExtractable *extractable;
|
|
GESLayer *layer;
|
|
gchar *uri;
|
|
gchar *uri1;
|
|
GESTimeline *timeline;
|
|
|
|
ges_init ();
|
|
|
|
layer = ges_layer_new ();
|
|
uri = ges_test_file_uri ("audio_video.ogg");
|
|
uri1 = ges_test_file_uri ("audio_only.ogg");
|
|
timeline = ges_timeline_new_audio_video ();
|
|
|
|
ges_timeline_add_layer (timeline, layer);
|
|
|
|
asset = GES_ASSET (ges_uri_clip_asset_request_sync (uri, NULL));
|
|
|
|
fail_unless (GES_IS_ASSET (asset));
|
|
fail_unless_equals_string (ges_asset_get_id (asset), uri);
|
|
|
|
extractable = GES_EXTRACTABLE (ges_layer_add_asset (layer,
|
|
asset, 0, 0, GST_CLOCK_TIME_NONE, GES_TRACK_TYPE_UNKNOWN));
|
|
fail_unless (ges_extractable_get_asset (extractable) == asset);
|
|
gst_object_unref (asset);
|
|
|
|
/* Now try to set the a and see if the vtype is properly updated */
|
|
asset1 = GES_ASSET (ges_uri_clip_asset_request_sync (uri1, NULL));
|
|
fail_unless_equals_int (g_list_length (GES_CONTAINER_CHILDREN (extractable)),
|
|
2);
|
|
fail_unless (ges_extractable_set_asset (extractable, asset1));
|
|
fail_unless_equals_int (g_list_length (GES_CONTAINER_CHILDREN (extractable)),
|
|
1);
|
|
|
|
gst_object_unref (extractable);
|
|
|
|
g_free (uri);
|
|
g_free (uri1);
|
|
|
|
gst_object_unref (asset1);
|
|
gst_object_unref (asset);
|
|
|
|
ges_deinit ();
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_list_asset)
|
|
{
|
|
GList *assets;
|
|
GEnumClass *enum_class;
|
|
|
|
ges_init ();
|
|
|
|
enum_class = g_type_class_peek (GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE);
|
|
|
|
fail_unless (ges_init ());
|
|
fail_if (ges_list_assets (GES_TYPE_OVERLAY_CLIP));
|
|
|
|
assets = ges_list_assets (GES_TYPE_TRANSITION_CLIP);
|
|
/* note: we do not have a a for value=0 "Transition not set" */
|
|
assert_equals_int (g_list_length (assets), enum_class->n_values - 1);
|
|
g_list_free (assets);
|
|
|
|
ges_deinit ();
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/*
|
|
* NOTE: this test is commented out because it requires the internal
|
|
* ges_asset_finish_proxy method. This method replaces the behaviour of
|
|
* ges_asset_set_proxy (NULL, proxy), which is no longer supported.
|
|
*
|
|
* ges_asset_cache_lookup and ges_asset_try_proxy are similarly internal,
|
|
* but they are marked with GES_API in ges-internal.h
|
|
* The newer ges_asset_finish_proxy is not marked as GES_API, because it
|
|
* would add it to the symbols list, and could therefore not be easily
|
|
* removed.
|
|
*
|
|
* Once we have a nice way to call internal methods for tests, we should
|
|
* uncomment this.
|
|
*
|
|
GST_START_TEST (test_proxy_asset)
|
|
{
|
|
GESAsset *identity, *nothing, *nothing_at_all;
|
|
|
|
fail_unless (ges_init ());
|
|
|
|
identity = ges_asset_request (GES_TYPE_EFFECT, "video identity", NULL);
|
|
fail_unless (identity != NULL);
|
|
|
|
nothing = ges_asset_request (GES_TYPE_EFFECT, "nothing", NULL);
|
|
fail_if (nothing);
|
|
|
|
nothing = ges_asset_cache_lookup (GES_TYPE_EFFECT, "nothing");
|
|
fail_unless (nothing != NULL);
|
|
|
|
fail_unless (ges_asset_try_proxy (nothing, "video identity"));
|
|
fail_unless (ges_asset_finish_proxy (identity));
|
|
|
|
nothing_at_all = ges_asset_request (GES_TYPE_EFFECT, "nothing_at_all", NULL);
|
|
fail_if (nothing_at_all);
|
|
|
|
nothing_at_all = ges_asset_cache_lookup (GES_TYPE_EFFECT, "nothing_at_all");
|
|
fail_unless (nothing_at_all != NULL);
|
|
|
|
// Now we proxy nothing_at_all to nothing which is itself proxied to identity
|
|
fail_unless (ges_asset_try_proxy (nothing_at_all, "nothing"));
|
|
fail_unless (ges_asset_finish_proxy (nothing));
|
|
fail_unless_equals_int (g_list_length (ges_asset_list_proxies
|
|
(nothing_at_all)), 1);
|
|
|
|
fail_unless_equals_pointer (ges_asset_get_proxy_target (nothing),
|
|
nothing_at_all);
|
|
|
|
// If we request nothing_at_all we should get the good proxied identity
|
|
nothing_at_all = ges_asset_request (GES_TYPE_EFFECT, "nothing_at_all", NULL);
|
|
fail_unless (nothing_at_all == identity);
|
|
|
|
gst_object_unref (identity);
|
|
gst_object_unref (nothing_at_all);
|
|
|
|
ges_deinit ();
|
|
}
|
|
|
|
GST_END_TEST;
|
|
*/
|
|
|
|
static void
|
|
_count_cb (GObject * obj, GParamSpec * pspec, gpointer key)
|
|
{
|
|
guint count = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (obj), key));
|
|
g_object_set_data (G_OBJECT (obj), key, GUINT_TO_POINTER (count + 1));
|
|
}
|
|
|
|
#define _CONNECT_PROXY_SIGNALS(asset) \
|
|
g_signal_connect (asset, "notify::proxy", G_CALLBACK (_count_cb), \
|
|
(gchar *)"test-data-proxy-count"); \
|
|
g_signal_connect (asset, "notify::proxy-target", G_CALLBACK (_count_cb), \
|
|
(gchar *)"test-data-target-count");
|
|
|
|
/* test that @asset has the properties proxy = @proxy and
|
|
* proxy-target = @proxy_target
|
|
* Also check that the callback for "notify::proxy" (set up in
|
|
* _CONNECT_PROXY_SIGNALS) has been called @p_count times, and the
|
|
* callback for "notify::target-proxy" has been called @t_count times.
|
|
*/
|
|
#define _assert_proxy_state(asset, proxy, proxy_target, p_count, t_count) \
|
|
{ \
|
|
const gchar *id = ges_asset_get_id (asset); \
|
|
guint found_p_count = GPOINTER_TO_UINT (g_object_get_data ( \
|
|
G_OBJECT (asset), "test-data-proxy-count")); \
|
|
guint found_t_count = GPOINTER_TO_UINT (g_object_get_data ( \
|
|
G_OBJECT (asset), "test-data-target-count")); \
|
|
GESAsset *found_proxy = ges_asset_get_proxy (asset); \
|
|
GESAsset *found_target = ges_asset_get_proxy_target (asset); \
|
|
fail_unless (found_proxy == proxy, "Asset '%s' has the proxy '%s' " \
|
|
"rather than the expected '%s'", id, \
|
|
found_proxy ? ges_asset_get_id (found_proxy) : NULL, \
|
|
proxy ? ges_asset_get_id (proxy) : NULL); \
|
|
fail_unless (found_target == proxy_target, "Asset '%s' has the proxy " \
|
|
"target '%s' rather than the expected '%s'", id, \
|
|
found_target ? ges_asset_get_id (found_target) : NULL, \
|
|
proxy_target ? ges_asset_get_id (proxy_target) : NULL); \
|
|
fail_unless (p_count == found_p_count, "notify::proxy for asset '%s' " \
|
|
"was called %u times, rather than the expected %u times", \
|
|
id, found_p_count, p_count); \
|
|
fail_unless (t_count == found_t_count, "notify::target-proxy for " \
|
|
"asset '%s' was called %u times, rather than the expected %u times", \
|
|
id, found_t_count, t_count); \
|
|
}
|
|
|
|
#define _assert_proxy_list(asset, cmp_list) \
|
|
{ \
|
|
const gchar * id = ges_asset_get_id (asset); \
|
|
int i; \
|
|
GList *tmp; \
|
|
for (i = 0, tmp = ges_asset_list_proxies (asset); cmp_list[i] && tmp; \
|
|
i++, tmp = tmp->next) { \
|
|
GESAsset *proxy = tmp->data; \
|
|
fail_unless (proxy == cmp_list[i], "The asset '%s' has '%s' as its " \
|
|
"%ith proxy, rather than the expected '%s'", id, \
|
|
ges_asset_get_id (proxy), i, ges_asset_get_id (cmp_list[i])); \
|
|
} \
|
|
fail_unless (tmp == NULL, "Found more proxies for '%s' than expected", \
|
|
id); \
|
|
fail_unless (cmp_list[i] == NULL, "Found less proxies (%i) for '%s' " \
|
|
"than expected", i, id); \
|
|
}
|
|
|
|
#define _assert_effect_asset_request(req_id, expect) \
|
|
{ \
|
|
GESAsset *requested = ges_asset_request (GES_TYPE_EFFECT, req_id, NULL); \
|
|
fail_unless (requested == expect, "Requested asset for id '%s' is " \
|
|
"'%s' rather than the expected '%s'", req_id, \
|
|
requested ? ges_asset_get_id (requested) : NULL, \
|
|
ges_asset_get_id (expect)); \
|
|
gst_object_unref (requested); \
|
|
}
|
|
|
|
GST_START_TEST (test_proxy_setters)
|
|
{
|
|
GESAsset *proxies[] = { NULL, NULL, NULL, NULL };
|
|
GESAsset *asset, *alt_asset;
|
|
GESAsset *proxy0, *proxy1, *proxy2;
|
|
gchar asset_id[] = "video agingtv ! videobalance";
|
|
gchar alt_asset_id[] = "video gamma";
|
|
gchar proxy0_id[] = "video videobalance contrast=0.0";
|
|
gchar proxy1_id[] = "video videobalance contrast=1.0";
|
|
gchar proxy2_id[] = "video videobalance contrast=2.0";
|
|
|
|
ges_init ();
|
|
|
|
asset = ges_asset_request (GES_TYPE_EFFECT, asset_id, NULL);
|
|
alt_asset = ges_asset_request (GES_TYPE_EFFECT, alt_asset_id, NULL);
|
|
|
|
proxy0 = ges_asset_request (GES_TYPE_EFFECT, proxy0_id, NULL);
|
|
proxy1 = ges_asset_request (GES_TYPE_EFFECT, proxy1_id, NULL);
|
|
proxy2 = ges_asset_request (GES_TYPE_EFFECT, proxy2_id, NULL);
|
|
|
|
/* make sure our assets are unique */
|
|
fail_unless (asset);
|
|
fail_unless (alt_asset);
|
|
fail_unless (proxy0);
|
|
fail_unless (proxy1);
|
|
fail_unless (proxy2);
|
|
fail_unless (asset != alt_asset);
|
|
fail_unless (asset != proxy0);
|
|
fail_unless (asset != proxy1);
|
|
fail_unless (asset != proxy2);
|
|
fail_unless (alt_asset != proxy0);
|
|
fail_unless (alt_asset != proxy1);
|
|
fail_unless (alt_asset != proxy2);
|
|
fail_unless (proxy0 != proxy1);
|
|
fail_unless (proxy0 != proxy1);
|
|
fail_unless (proxy0 != proxy2);
|
|
fail_unless (proxy1 != proxy2);
|
|
|
|
_CONNECT_PROXY_SIGNALS (asset);
|
|
_CONNECT_PROXY_SIGNALS (alt_asset);
|
|
_CONNECT_PROXY_SIGNALS (proxy0);
|
|
_CONNECT_PROXY_SIGNALS (proxy1);
|
|
_CONNECT_PROXY_SIGNALS (proxy2);
|
|
|
|
/* no proxies to start with */
|
|
_assert_proxy_state (asset, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (alt_asset, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (proxy0, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (proxy1, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 0);
|
|
_assert_proxy_list (asset, proxies);
|
|
_assert_proxy_list (alt_asset, proxies);
|
|
_assert_proxy_list (proxy0, proxies);
|
|
_assert_proxy_list (proxy1, proxies);
|
|
_assert_proxy_list (proxy2, proxies);
|
|
|
|
/* id for an asset with no proxy returns itself */
|
|
_assert_effect_asset_request (asset_id, asset);
|
|
_assert_effect_asset_request (alt_asset_id, alt_asset);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* set a proxy */
|
|
fail_unless (ges_asset_set_proxy (asset, proxy0));
|
|
_assert_proxy_state (asset, proxy0, NULL, 1, 0);
|
|
_assert_proxy_state (proxy0, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy1, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 0);
|
|
|
|
proxies[0] = proxy0;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
/* requesting the same asset should return the proxy instead */
|
|
_assert_effect_asset_request (asset_id, proxy0);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* can't proxy a different asset */
|
|
/* Raises ERROR */
|
|
fail_unless (ges_asset_set_proxy (alt_asset, proxy0) == FALSE);
|
|
_assert_proxy_state (alt_asset, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (asset, proxy0, NULL, 1, 0);
|
|
_assert_proxy_state (proxy0, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy1, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 0);
|
|
|
|
_assert_proxy_list (asset, proxies);
|
|
_assert_effect_asset_request (asset_id, proxy0);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
|
|
/* set the same proxy again is safe */
|
|
fail_unless (ges_asset_set_proxy (asset, proxy0));
|
|
/* notify::proxy callback count increases, even though we set the same
|
|
* proxy. This is the default behaviour for setters. */
|
|
_assert_proxy_state (asset, proxy0, NULL, 2, 0);
|
|
/* but the notify::target-proxy has not increased for the proxy */
|
|
_assert_proxy_state (proxy0, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy1, NULL, NULL, 0, 0);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 0);
|
|
|
|
_assert_proxy_list (asset, proxies);
|
|
_assert_effect_asset_request (asset_id, proxy0);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
|
|
/* replace the proxy with a new one */
|
|
fail_unless (ges_asset_set_proxy (asset, proxy1));
|
|
_assert_proxy_state (asset, proxy1, NULL, 3, 0);
|
|
/* first proxy still keeps its target */
|
|
_assert_proxy_state (proxy0, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy1, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 0);
|
|
|
|
proxies[0] = proxy1;
|
|
proxies[1] = proxy0;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, proxy1);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* replace again */
|
|
fail_unless (ges_asset_set_proxy (asset, proxy2));
|
|
_assert_proxy_state (asset, proxy2, NULL, 4, 0);
|
|
_assert_proxy_state (proxy0, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy1, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy2, NULL, asset, 0, 1);
|
|
|
|
proxies[0] = proxy2;
|
|
proxies[1] = proxy1;
|
|
proxies[2] = proxy0;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, proxy2);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* move proxy0 back to being the default */
|
|
fail_unless (ges_asset_set_proxy (asset, proxy0));
|
|
_assert_proxy_state (asset, proxy0, NULL, 5, 0);
|
|
_assert_proxy_state (proxy0, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy1, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy2, NULL, asset, 0, 1);
|
|
|
|
proxies[0] = proxy0;
|
|
proxies[1] = proxy2;
|
|
proxies[2] = proxy1;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, proxy0);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* remove proxy2 */
|
|
fail_unless (ges_asset_unproxy (asset, proxy2));
|
|
/* notify::proxy not released since we have not switched defaults */
|
|
_assert_proxy_state (asset, proxy0, NULL, 5, 0);
|
|
_assert_proxy_state (proxy0, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy1, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 2);
|
|
|
|
proxies[0] = proxy0;
|
|
proxies[1] = proxy1;
|
|
proxies[2] = NULL;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, proxy0);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* make proxy2 a proxy for proxy0 */
|
|
fail_unless (ges_asset_set_proxy (proxy0, proxy2));
|
|
_assert_proxy_state (asset, proxy0, NULL, 5, 0);
|
|
_assert_proxy_state (proxy0, proxy2, asset, 1, 1);
|
|
_assert_proxy_state (proxy1, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy2, NULL, proxy0, 0, 3);
|
|
|
|
proxies[0] = proxy0;
|
|
proxies[1] = proxy1;
|
|
proxies[2] = NULL;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
proxies[0] = proxy2;
|
|
proxies[1] = NULL;
|
|
_assert_proxy_list (proxy0, proxies);
|
|
|
|
/* original id will now follows two proxy links to get proxy2 */
|
|
_assert_effect_asset_request (asset_id, proxy2);
|
|
_assert_effect_asset_request (proxy0_id, proxy2);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* remove proxy0 from asset, should now default to proxy1 */
|
|
fail_unless (ges_asset_unproxy (asset, proxy0));
|
|
/* notify::proxy released since we have switched defaults */
|
|
_assert_proxy_state (asset, proxy1, NULL, 6, 0);
|
|
_assert_proxy_state (proxy0, proxy2, NULL, 1, 2);
|
|
_assert_proxy_state (proxy1, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy2, NULL, proxy0, 0, 3);
|
|
|
|
proxies[0] = proxy1;
|
|
proxies[1] = NULL;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
proxies[0] = proxy2;
|
|
proxies[1] = NULL;
|
|
_assert_proxy_list (proxy0, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, proxy1);
|
|
_assert_effect_asset_request (proxy0_id, proxy2);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* remove proxy2 from proxy0 */
|
|
fail_unless (ges_asset_unproxy (proxy0, proxy2));
|
|
_assert_proxy_state (asset, proxy1, NULL, 6, 0);
|
|
_assert_proxy_state (proxy0, NULL, NULL, 2, 2);
|
|
_assert_proxy_state (proxy1, NULL, asset, 0, 1);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 4);
|
|
|
|
proxies[0] = proxy1;
|
|
proxies[1] = NULL;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
proxies[0] = NULL;
|
|
_assert_proxy_list (proxy0, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, proxy1);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* make both proxy0 and proxy2 proxies of proxy1 */
|
|
fail_unless (ges_asset_set_proxy (proxy1, proxy0));
|
|
_assert_proxy_state (asset, proxy1, NULL, 6, 0);
|
|
_assert_proxy_state (proxy0, NULL, proxy1, 2, 3);
|
|
_assert_proxy_state (proxy1, proxy0, asset, 1, 1);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 4);
|
|
fail_unless (ges_asset_set_proxy (proxy1, proxy2));
|
|
_assert_proxy_state (asset, proxy1, NULL, 6, 0);
|
|
_assert_proxy_state (proxy0, NULL, proxy1, 2, 3);
|
|
_assert_proxy_state (proxy1, proxy2, asset, 2, 1);
|
|
_assert_proxy_state (proxy2, NULL, proxy1, 0, 5);
|
|
|
|
proxies[0] = proxy1;
|
|
proxies[1] = NULL;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
proxies[0] = proxy2;
|
|
proxies[1] = proxy0;
|
|
proxies[2] = NULL;
|
|
_assert_proxy_list (proxy1, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, proxy2);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy2);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* should not be able to set up any circular proxies */
|
|
/* Raises ERROR */
|
|
fail_unless (ges_asset_set_proxy (proxy1, asset) == FALSE);
|
|
_assert_proxy_state (asset, proxy1, NULL, 6, 0);
|
|
_assert_proxy_state (proxy0, NULL, proxy1, 2, 3);
|
|
_assert_proxy_state (proxy1, proxy2, asset, 2, 1);
|
|
_assert_proxy_state (proxy2, NULL, proxy1, 0, 5);
|
|
/* Raises ERROR */
|
|
fail_unless (ges_asset_set_proxy (proxy0, asset) == FALSE);
|
|
_assert_proxy_state (asset, proxy1, NULL, 6, 0);
|
|
_assert_proxy_state (proxy0, NULL, proxy1, 2, 3);
|
|
_assert_proxy_state (proxy1, proxy2, asset, 2, 1);
|
|
_assert_proxy_state (proxy2, NULL, proxy1, 0, 5);
|
|
/* Raises ERROR */
|
|
fail_unless (ges_asset_set_proxy (proxy2, asset) == FALSE);
|
|
_assert_proxy_state (asset, proxy1, NULL, 6, 0);
|
|
_assert_proxy_state (proxy0, NULL, proxy1, 2, 3);
|
|
_assert_proxy_state (proxy1, proxy2, asset, 2, 1);
|
|
_assert_proxy_state (proxy2, NULL, proxy1, 0, 5);
|
|
|
|
/* remove last proxy from asset, should set its proxy to NULL */
|
|
fail_unless (ges_asset_unproxy (asset, proxy1));
|
|
_assert_proxy_state (asset, NULL, NULL, 7, 0);
|
|
_assert_proxy_state (proxy0, NULL, proxy1, 2, 3);
|
|
_assert_proxy_state (proxy1, proxy2, NULL, 2, 2);
|
|
_assert_proxy_state (proxy2, NULL, proxy1, 0, 5);
|
|
|
|
proxies[0] = NULL;
|
|
_assert_proxy_list (asset, proxies);
|
|
|
|
proxies[0] = proxy2;
|
|
proxies[1] = proxy0;
|
|
proxies[2] = NULL;
|
|
_assert_proxy_list (proxy1, proxies);
|
|
|
|
/* get asset back */
|
|
_assert_effect_asset_request (asset_id, asset);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy2);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
/* set the proxy property to NULL for proxy1, should remove all of
|
|
* its proxies */
|
|
fail_unless (ges_asset_set_proxy (proxy1, NULL));
|
|
_assert_proxy_state (asset, NULL, NULL, 7, 0);
|
|
/* only one notify for proxy1, but two separate ones for ex-proxies */
|
|
_assert_proxy_state (proxy0, NULL, NULL, 2, 4);
|
|
_assert_proxy_state (proxy1, NULL, NULL, 3, 2);
|
|
_assert_proxy_state (proxy2, NULL, NULL, 0, 6);
|
|
|
|
proxies[0] = NULL;
|
|
_assert_proxy_list (asset, proxies);
|
|
_assert_proxy_list (proxy0, proxies);
|
|
_assert_proxy_list (proxy1, proxies);
|
|
_assert_proxy_list (proxy2, proxies);
|
|
|
|
_assert_effect_asset_request (asset_id, asset);
|
|
_assert_effect_asset_request (proxy0_id, proxy0);
|
|
_assert_effect_asset_request (proxy1_id, proxy1);
|
|
_assert_effect_asset_request (proxy2_id, proxy2);
|
|
|
|
gst_object_unref (asset);
|
|
gst_object_unref (alt_asset);
|
|
gst_object_unref (proxy0);
|
|
gst_object_unref (proxy1);
|
|
gst_object_unref (proxy2);
|
|
|
|
ges_deinit ();
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static Suite *
|
|
ges_suite (void)
|
|
{
|
|
Suite *s = suite_create ("ges");
|
|
TCase *tc_chain = tcase_create ("a");
|
|
|
|
suite_add_tcase (s, tc_chain);
|
|
|
|
tcase_add_test (tc_chain, test_basic);
|
|
tcase_add_test (tc_chain, test_custom_context);
|
|
tcase_add_test (tc_chain, test_transition_change_asset);
|
|
tcase_add_test (tc_chain, test_uri_clip_change_asset);
|
|
tcase_add_test (tc_chain, test_list_asset);
|
|
tcase_add_test (tc_chain, test_proxy_setters);
|
|
|
|
return s;
|
|
}
|
|
|
|
GST_CHECK_MAIN (ges);
|