From 35a01f41ce312b53a2ad82ce8a65b3561c3abf81 Mon Sep 17 00:00:00 2001 From: George Kiagiadakis Date: Wed, 5 Jul 2017 16:53:48 +0300 Subject: [PATCH] tests/check: add automatic unit test suite for the ipcpipeline elements All tests run within a common framework for splitting processes and making them interract properly with the gst check system. --- .gitignore | 1 + tests/check/Makefile.am | 4 + tests/check/pipelines/ipcpipeline.c | 5989 +++++++++++++++++++++++++++++++++++ tests/files/sine.wav | Bin 0 -> 577592 bytes tests/files/test.ts | Bin 0 -> 400628 bytes 5 files changed, 5994 insertions(+) create mode 100644 tests/check/pipelines/ipcpipeline.c create mode 100644 tests/files/sine.wav create mode 100644 tests/files/test.ts diff --git a/.gitignore b/.gitignore index ba25bd1..297267d 100644 --- a/.gitignore +++ b/.gitignore @@ -53,6 +53,7 @@ gst*orc.h /tests/check/elements/videoframe-audiolevel /tests/check/elements/pnm /tests/check/pipelines/simple-launch-lines +/tests/check/pipelines/ipcpipeline /tests/examples/audiomixmatrix/test-audiomixmatrix /tests/examples/codecparsers/parse-jpeg /tests/examples/codecparsers/parse-vp8 diff --git a/tests/check/Makefile.am b/tests/check/Makefile.am index b3ae602..3f3a677 100644 --- a/tests/check/Makefile.am +++ b/tests/check/Makefile.am @@ -272,6 +272,7 @@ check_PROGRAMS = \ elements/rtponviftimestamp \ elements/id3mux \ pipelines/mxf \ + pipelines/ipcpipeline \ libs/mpegvideoparser \ libs/mpegts \ libs/h264parser \ @@ -476,6 +477,9 @@ elements_mssdemux_SOURCES = elements/test_http_src.c elements/test_http_src.h el pipelines_streamheader_CFLAGS = $(GIO_CFLAGS) $(AM_CFLAGS) pipelines_streamheader_LDADD = $(GIO_LIBS) $(LDADD) +pipelines_ipcpipeline_CFLAGS = $(GST_VALIDATE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS) $(GIO_CFLAGS) $(AM_CFLAGS) +pipelines_ipcpipeline_LDADD = $(GST_VALIDATE_LIBS) $(GST_BASE_LIBS) $(GST_LIBS) $(GIO_LIBS) $(LDADD) + libs_insertbin_LDADD = \ $(top_builddir)/gst-libs/gst/insertbin/libgstinsertbin-@GST_API_VERSION@.la \ $(GST_PLUGINS_BASE_LIBS) $(GST_BASE_LIBS) $(GST_LIBS) $(LDADD) diff --git a/tests/check/pipelines/ipcpipeline.c b/tests/check/pipelines/ipcpipeline.c new file mode 100644 index 0000000..e4ba78b --- /dev/null +++ b/tests/check/pipelines/ipcpipeline.c @@ -0,0 +1,5989 @@ +/* GStreamer + * + * tests for the ipcpipelinesrc/ipcpipelinesink elements + * + * Copyright (C) 2015-2017 YouView TV Ltd + * Author: Vincent Penquerc'h + * Author: George Kiagiadakis + * + * 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. + */ + +#define _GNU_SOURCE /* See feature_test_macros(7) */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* This enum contains flags that are used to configure the setup that + * test_base() will do internally */ +typedef enum +{ + /* Features related to the multi-process setup */ + TEST_FEATURE_SPLIT_SINKS = 0x1, /* separate audio and video sink processes */ + TEST_FEATURE_RECOVERY_SLAVE_PROCESS = 0x2, + TEST_FEATURE_RECOVERY_MASTER_PROCESS = 0x4, + + TEST_FEATURE_HAS_VIDEO = 0x10, + TEST_FEATURE_LIVE = 0x20, /* sets is-live=true in {audio,video}testsrc */ + TEST_FEATURE_ASYNC_SINK = 0x40, /* sets sync=false in fakesink */ + TEST_FEATURE_ERROR_SINK = 0x80, /* generates error message in the slave */ + TEST_FEATURE_LONG_DURATION = 0x100, /* bigger num-buffers in {audio,video}testsrc */ + TEST_FEATURE_FILTER_SINK_CAPS = 0x200, /* plugs capsfilter before fakesink */ + + /* Source selection; Use only one of those, do not combine! */ + TEST_FEATURE_TEST_SOURCE = 0x400, + TEST_FEATURE_WAV_SOURCE = 0x800, + TEST_FEATURE_MPEGTS_SOURCE = 0x1000 | TEST_FEATURE_HAS_VIDEO, + TEST_FEATURE_LIVE_A_SOURCE = + TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_LIVE | TEST_FEATURE_ASYNC_SINK, + TEST_FEATURE_LIVE_AV_SOURCE = + TEST_FEATURE_LIVE_A_SOURCE | TEST_FEATURE_HAS_VIDEO, +} TestFeatures; + +/* This is the data structure that each function of the each test receives + * in user_data. It contains pointers to stack-allocated, test-specific + * structures that contain the test parameters (input data), the runtime + * data of the master (source) process (master data) and the runtime data + * of the slave (sink) process (slave data) */ +typedef struct +{ + gpointer id; /* input data struct */ + gpointer md; /* master data struct */ + gpointer sd; /* slave data struct */ + + TestFeatures features; /* the features that this test is running with */ + + /* whether there is both an audio and a video stream + * in this process'es pipeline */ + gboolean two_streams; + + /* the pipeline of this process; could be either master or slave */ + GstElement *p; + + /* this callback will be called in the master process when + * the master gets STATE_CHANGED with the new state being state_target */ + void (*state_changed_cb) (gpointer); + GstState state_target; + +} test_data; + +/* All pipelines do not start buffers at exactly zero, so we consider + timestamps within a small tolerance to be zero */ +#define CLOSE_ENOUGH_TO_ZERO (GST_SECOND / 5) + +/* milliseconds */ +#define STEP_AT 100 +#define PAUSE_AT 500 +#define SEEK_AT 700 +#define QUERY_AT 600 +#define MESSAGE_AT 600 +#define CRASH_AT 600 +#define STOP_AT 600 + +/* Rough duration of the sample files we use */ +#define MPEGTS_SAMPLE_ROUGH_DURATION (GST_SECOND * 64 / 10) +#define WAV_SAMPLE_ROUGH_DURATION (GST_SECOND * 65 / 10) + +enum +{ + MSG_ACK = 0, + MSG_START = 1 +}; + +static GMainLoop *loop; +static gboolean child_dead; +static int pipesfa[2], pipesba[2], pipesfv[2], pipesbv[2]; +static int ctlsock[2]; +static int recovery_pid = 0; +static int check_fd = -1; +static GList *weak_refs = NULL; + +/* lock helpers */ + +#define FAIL_IF(x) do { lock_check (); fail_if(x); unlock_check (); } while(0) +#define FAIL_UNLESS(x) do { lock_check (); fail_unless(x); unlock_check (); } while(0) +#define FAIL_UNLESS_EQUALS_INT(x,y) do { lock_check (); fail_unless_equals_int(x,y); unlock_check (); } while(0) +#define FAIL() do { lock_check (); fail(); unlock_check (); } while(0) + +static void +lock_check (void) +{ + flock (check_fd, LOCK_EX); +} + +static void +unlock_check (void) +{ + flock (check_fd, LOCK_UN); +} + +static void +setup_lock (void) +{ + gchar *name = NULL; + check_fd = g_file_open_tmp (NULL, &name, NULL); + unlink (name); + g_free (name); +} + +/* tracking for ipcpipeline elements; this is used mainly to detect leaks, + * but also to provide a method for calling "disconnect" on all of them + * in the tests that require it */ + +static void +remove_weak_ref (GstElement * element) +{ + weak_refs = g_list_remove (weak_refs, element); +} + +static void +add_weak_ref (GstElement * element) +{ + weak_refs = g_list_append (weak_refs, element); + g_object_weak_ref (G_OBJECT (element), (GWeakNotify) remove_weak_ref, + element); +} + +static void +disconnect_ipcpipeline_elements (void) +{ + GList *l; + + for (l = weak_refs; l; l = l->next) { + g_signal_emit_by_name (G_OBJECT (l->data), "disconnect", NULL); + } +} + +/* helper functions */ + +static void +cleanup_bus (GstElement * pipeline) +{ + gst_bus_remove_watch (GST_ELEMENT_BUS (pipeline)); + gst_bus_set_flushing (GST_ELEMENT_BUS (pipeline), TRUE); +} + +static void +setup_log (const char *logfile, int append) +{ + FILE *f; + + f = fopen (logfile, append ? "a+" : "w"); + gst_debug_add_log_function (gst_debug_log_default, f, NULL); +} + +static GstElement * +create_pipeline (const char *type) +{ + GstElement *pipeline; + + pipeline = gst_element_factory_make (type, NULL); + FAIL_UNLESS (pipeline); + + return pipeline; +} + +static GQuark +to_be_removed_quark (void) +{ + static GQuark q = 0; + if (!q) + q = g_quark_from_static_string ("to_be_removed"); + return q; +} + +static gboolean +are_caps_audio (const GstCaps * caps) +{ + GstStructure *structure; + const char *name; + + structure = gst_caps_get_structure (caps, 0); + name = gst_structure_get_name (structure); + return g_str_has_prefix (name, "audio/"); +} + +static gboolean +are_caps_video (const GstCaps * caps) +{ + GstStructure *structure; + const char *name; + + structure = gst_caps_get_structure (caps, 0); + name = gst_structure_get_name (structure); + return (g_str_has_prefix (name, "video/") + && strcmp (name, "video/x-dvd-subpicture")); +} + +static int +caps2idx (GstCaps * caps, gboolean two_streams) +{ + int idx; + + if (!two_streams) + return 0; + + if (are_caps_audio (caps)) { + idx = 0; + } else if (are_caps_video (caps)) { + idx = 1; + } else { + FAIL_IF (1); + idx = 0; + } + return idx; +} + +static int +pad2idx (GstPad * pad, gboolean two_streams) +{ + GstCaps *caps; + int idx; + + if (!two_streams) + return 0; + + caps = gst_pad_get_current_caps (pad); + if (!caps) + caps = gst_pad_get_pad_template_caps (pad); + FAIL_UNLESS (caps); + + idx = caps2idx (caps, two_streams); + + gst_caps_unref (caps); + return idx; +} + +static gboolean +stop_pipeline (gpointer user_data) +{ + GstElement *pipeline = user_data; + GstStateChangeReturn ret; + + ret = gst_element_set_state (pipeline, GST_STATE_NULL); + FAIL_IF (ret == GST_STATE_CHANGE_FAILURE); + gst_object_unref (pipeline); + g_main_loop_quit (loop); + return FALSE; +} + +/* the master process'es async GstBus callback */ +static gboolean +master_bus_msg (GstBus * bus, GstMessage * message, gpointer user_data) +{ + test_data *td = user_data; + + switch (GST_MESSAGE_TYPE (message)) { + case GST_MESSAGE_ERROR:{ + GError *err; + gchar *dbg; + + /* elements we are removing might error out as they are taken out + of the pipeline, and fail to push. We don't care about those. */ + if (g_object_get_qdata (G_OBJECT (GST_MESSAGE_SRC (message)), + to_be_removed_quark ())) + break; + + gst_message_parse_error (message, &err, &dbg); + g_printerr ("ERROR: %s\n", err->message); + if (dbg != NULL) + g_printerr ("ERROR debug information: %s\n", dbg); + g_error_free (err); + g_free (dbg); + g_assert_not_reached (); + break; + } + case GST_MESSAGE_WARNING:{ + GError *err; + gchar *dbg; + + gst_message_parse_warning (message, &err, &dbg); + g_printerr ("WARNING: %s\n", err->message); + if (dbg != NULL) + g_printerr ("WARNING debug information: %s\n", dbg); + g_error_free (err); + g_free (dbg); + g_assert_not_reached (); + break; + } + case GST_MESSAGE_EOS: + g_main_loop_quit (loop); + break; + case GST_MESSAGE_STATE_CHANGED: + if (GST_MESSAGE_SRC (message) == GST_OBJECT_CAST (td->p) + && td->state_changed_cb) { + GstState state; + gst_message_parse_state_changed (message, NULL, &state, NULL); + if (state == td->state_target) + td->state_changed_cb (td); + } + break; + default: + break; + } + return TRUE; +} + +/* source construction functions */ + +static GstElement * +create_wavparse_source_loc (const char *loc, int fdina, int fdouta) +{ + GstElement *sbin, *pipeline, *filesrc, *ipcpipelinesink; + GError *e = NULL; + + pipeline = create_pipeline ("pipeline"); + sbin = + gst_parse_bin_from_description ("pushfilesrc name=filesrc ! wavparse", + TRUE, &e); + FAIL_IF (e || !sbin); + gst_element_set_name (sbin, "source"); + filesrc = gst_bin_get_by_name (GST_BIN (sbin), "filesrc"); + FAIL_UNLESS (filesrc); + g_object_set (filesrc, "location", loc, NULL); + gst_object_unref (filesrc); + ipcpipelinesink = + gst_element_factory_make ("ipcpipelinesink", "ipcpipelinesink"); + add_weak_ref (ipcpipelinesink); + g_object_set (ipcpipelinesink, "fdin", fdina, "fdout", fdouta, NULL); + gst_bin_add_many (GST_BIN (pipeline), sbin, ipcpipelinesink, NULL); + FAIL_UNLESS (gst_element_link_many (sbin, ipcpipelinesink, NULL)); + + return pipeline; +} + +static void +on_pad_added (GstElement * element, GstPad * pad, gpointer data) +{ + GstCaps *caps; + GstElement *next; + GstBin *pipeline = data; + GstPad *sink_pad; + + caps = gst_pad_get_current_caps (pad); + if (!caps) + caps = gst_pad_get_pad_template_caps (pad); + + if (are_caps_video (caps)) { + next = gst_bin_get_by_name (GST_BIN (pipeline), "vqueue"); + } else if (are_caps_audio (caps)) { + next = gst_bin_get_by_name (GST_BIN (pipeline), "aqueue"); + } else { + gst_caps_unref (caps); + return; + } + gst_caps_unref (caps); + + FAIL_UNLESS (next); + sink_pad = gst_element_get_static_pad (next, "sink"); + FAIL_UNLESS (sink_pad); + FAIL_UNLESS (gst_pad_link (pad, sink_pad) == GST_PAD_LINK_OK); + gst_object_unref (sink_pad); + + gst_object_unref (next); +} + +static GstElement * +create_mpegts_source_loc (const char *loc, int fdina, int fdouta, int fdinv, + int fdoutv) +{ + GstElement *pipeline, *filesrc, *tsdemux, *aqueue, *vqueue, *aipcpipelinesink, + *vipcpipelinesink; + + pipeline = create_pipeline ("pipeline"); + filesrc = gst_element_factory_make ("filesrc", NULL); + g_object_set (filesrc, "location", loc, NULL); + tsdemux = gst_element_factory_make ("tsdemux", NULL); + g_signal_connect (tsdemux, "pad-added", G_CALLBACK (on_pad_added), pipeline); + aqueue = gst_element_factory_make ("queue", "aqueue"); + aipcpipelinesink = gst_element_factory_make ("ipcpipelinesink", NULL); + add_weak_ref (aipcpipelinesink); + g_object_set (aipcpipelinesink, "fdin", fdina, "fdout", fdouta, NULL); + vqueue = gst_element_factory_make ("queue", "vqueue"); + vipcpipelinesink = gst_element_factory_make ("ipcpipelinesink", NULL); + add_weak_ref (vipcpipelinesink); + g_object_set (vipcpipelinesink, "fdin", fdinv, "fdout", fdoutv, NULL); + gst_bin_add_many (GST_BIN (pipeline), filesrc, tsdemux, aqueue, + aipcpipelinesink, vqueue, vipcpipelinesink, NULL); + FAIL_UNLESS (gst_element_link_many (filesrc, tsdemux, NULL)); + FAIL_UNLESS (gst_element_link_many (aqueue, aipcpipelinesink, NULL)); + FAIL_UNLESS (gst_element_link_many (vqueue, vipcpipelinesink, NULL)); + + return pipeline; +} + +static GstElement * +create_test_source (gboolean live, int fdina, int fdouta, int fdinv, int fdoutv, + gboolean audio, gboolean video, gboolean Long) +{ + GstElement *pipeline, *audiotestsrc, *aipcpipelinesink; + GstElement *videotestsrc, *vipcpipelinesink; + int L = Long ? 2 : 1; + + pipeline = create_pipeline ("pipeline"); + + if (audio) { + audiotestsrc = gst_element_factory_make ("audiotestsrc", "audiotestsrc"); + g_object_set (audiotestsrc, "is-live", live, "num-buffers", + live ? 270 * L : 600, NULL); + aipcpipelinesink = gst_element_factory_make ("ipcpipelinesink", + "aipcpipelinesink"); + add_weak_ref (aipcpipelinesink); + g_object_set (aipcpipelinesink, "fdin", fdina, "fdout", fdouta, NULL); + gst_bin_add_many (GST_BIN (pipeline), audiotestsrc, aipcpipelinesink, NULL); + FAIL_UNLESS (gst_element_link_many (audiotestsrc, aipcpipelinesink, NULL)); + } + + if (video) { + videotestsrc = gst_element_factory_make ("videotestsrc", "videotestsrc"); + g_object_set (videotestsrc, "is-live", live, "num-buffers", + live ? 190 * L : 600, NULL); + vipcpipelinesink = + gst_element_factory_make ("ipcpipelinesink", "vipcpipelinesink"); + add_weak_ref (vipcpipelinesink); + g_object_set (vipcpipelinesink, "fdin", fdinv, "fdout", fdoutv, NULL); + gst_bin_add_many (GST_BIN (pipeline), videotestsrc, vipcpipelinesink, NULL); + FAIL_UNLESS (gst_element_link_many (videotestsrc, vipcpipelinesink, NULL)); + } + + return pipeline; +} + +static GstElement * +create_source (TestFeatures features, int fdina, int fdouta, int fdinv, + int fdoutv, test_data * td) +{ + GstElement *pipeline = NULL; + gboolean live = ! !(features & TEST_FEATURE_LIVE); + gboolean longdur = ! !(features & TEST_FEATURE_LONG_DURATION); + gboolean has_video = ! !(features & TEST_FEATURE_HAS_VIDEO); + + if (features & TEST_FEATURE_TEST_SOURCE) { + + pipeline = create_test_source (live, fdina, fdouta, fdinv, fdoutv, TRUE, + has_video, longdur); + } else if (features & TEST_FEATURE_WAV_SOURCE) { + pipeline = create_wavparse_source_loc ("../../tests/files/sine.wav", fdina, + fdouta); + } else if (features & TEST_FEATURE_MPEGTS_SOURCE) { + pipeline = create_mpegts_source_loc ("../../tests/files/test.ts", fdina, + fdouta, fdinv, fdoutv); + } else { + g_assert_not_reached (); + } + + td->two_streams = has_video; + td->p = pipeline; + + if (pipeline) + gst_bus_add_watch (GST_ELEMENT_BUS (pipeline), master_bus_msg, td); + + return pipeline; +} + +/* sink construction */ + +static GstElement * +create_sink (TestFeatures features, GstElement ** slave_pipeline, + int fdin, int fdout, const char *filter_caps) +{ + GstElement *ipcpipelinesrc, *fakesink, *identity, *capsfilter, *endpoint; + GstCaps *caps; + + if (!*slave_pipeline) + *slave_pipeline = create_pipeline ("ipcslavepipeline"); + else + gst_object_ref (*slave_pipeline); + ipcpipelinesrc = gst_element_factory_make ("ipcpipelinesrc", NULL); + add_weak_ref (ipcpipelinesrc); + g_object_set (ipcpipelinesrc, "fdin", fdin, "fdout", fdout, NULL); + fakesink = gst_element_factory_make ("fakesink", NULL); + g_object_set (fakesink, "sync", !(features & TEST_FEATURE_ASYNC_SINK), NULL); + gst_bin_add_many (GST_BIN (*slave_pipeline), ipcpipelinesrc, fakesink, NULL); + endpoint = ipcpipelinesrc; + + if (features & TEST_FEATURE_ERROR_SINK && + !g_strcmp0 (filter_caps, "audio/x-raw")) { + identity = gst_element_factory_make ("identity", "error-element"); + g_object_set (identity, "error-after", 5, NULL); + gst_bin_add (GST_BIN (*slave_pipeline), identity); + FAIL_UNLESS (gst_element_link_many (endpoint, identity, NULL)); + endpoint = identity; + } + + if ((features & TEST_FEATURE_FILTER_SINK_CAPS) && filter_caps) { + capsfilter = gst_element_factory_make ("capsfilter", NULL); + caps = gst_caps_from_string (filter_caps); + FAIL_UNLESS (caps); + g_object_set (capsfilter, "caps", caps, NULL); + gst_caps_unref (caps); + gst_bin_add (GST_BIN (*slave_pipeline), capsfilter); + FAIL_UNLESS (gst_element_link_many (endpoint, capsfilter, NULL)); + endpoint = capsfilter; + } + FAIL_UNLESS (gst_element_link_many (endpoint, fakesink, NULL)); + + return *slave_pipeline; +} + +static void +ensure_sink_setup (GstElement * sink, void (*setup_sink) (GstElement *, void *), + gpointer user_data) +{ + static GQuark setup_done = 0; + test_data *td = user_data; + + if (!setup_done) + setup_done = g_quark_from_static_string ("setup_done"); + + if (sink) + td->p = sink; + + if (sink && setup_sink && !g_object_get_qdata (G_OBJECT (sink), setup_done)) { + g_object_set_qdata (G_OBJECT (sink), setup_done, GINT_TO_POINTER (1)); + setup_sink (sink, user_data); + } +} + +/* GstCheck multi-process setup helpers */ + +static void +on_child_exit (int signal) +{ + int status = 0; + if (waitpid (-1, &status, 0) > 0 && status) { + FAIL (); + exit (status); + } else { + child_dead = TRUE; + } +} + +static void +die_on_child_death (void) +{ + struct sigaction sa; + + memset (&sa, 0, sizeof (sa)); + sa.sa_handler = on_child_exit; + sigaction (SIGCHLD, &sa, NULL); +} + +static void +wait_for_recovery (void) +{ + int value; + + FAIL_UNLESS (ctlsock[1]); + FAIL_UNLESS (read (ctlsock[1], &value, sizeof (int)) == sizeof (int)); + FAIL_UNLESS (value == MSG_START); +} + +static void +ack_recovery (void) +{ + int value = MSG_ACK; + FAIL_UNLESS (ctlsock[1]); + FAIL_UNLESS (write (ctlsock[1], &value, sizeof (int)) == sizeof (int)); +} + +static void +recreate_crashed_slave_process (void) +{ + int value = MSG_START; + /* We don't recreate, because there seems to be some subtle issues + with forking after gst has started running. So we create a new + recovery process at start, and wake it up after the current + slave dies, so it can take its place. It's a bit hacky, but it + works. The spare process waits for SIGUSR2 to setup a replacement + pipeline and connect to the master. */ + FAIL_UNLESS (recovery_pid); + FAIL_UNLESS (ctlsock[0]); + FAIL_UNLESS (write (ctlsock[0], &value, sizeof (int)) == sizeof (int)); + FAIL_UNLESS (read (ctlsock[0], &value, sizeof (int)) == sizeof (int)); + FAIL_UNLESS (value == MSG_ACK); +} + +static gboolean +crash (gpointer user_data) +{ + _exit (0); +} + +static gboolean +unwind (gpointer user_data) +{ + g_main_loop_quit (loop); + return FALSE; +} + +static void +on_unwind (int signal) +{ + g_idle_add (unwind, NULL); +} + +static void +listen_for_unwind (void) +{ + struct sigaction sa; + + memset (&sa, 0, sizeof (sa)); + sa.sa_handler = on_unwind; + sigaction (SIGUSR1, &sa, NULL); +} + +static void +stop_listening_for_unwind (void) +{ + struct sigaction sa; + + memset (&sa, 0, sizeof (sa)); + sa.sa_handler = SIG_DFL; + sigaction (SIGUSR1, &sa, NULL); +} + +#define TEST_BASE(...) test_base(__FUNCTION__,##__VA_ARGS__) + +/* + * This is the main function driving the tests. All tests configure it + * by way of all the function pointers it takes as arguments, which have + * self-explanatory names. + * Most tests are run over a number of different pipelines with the same + * configuration (eg, a wavparse based pipeline, a live pipeline with + * test audio/video, etc). Those pipelines that have more than one sink + * (eg, MPEG-TS source demuxing audio and video) have a version with a + * single slave pipeline and process, and a version with the audio and + * video sinks in two different processes, each with its slave pipeline. + * The master and slave crash tests are also run via this function, and + * have specific code (grep for recovery). + * There is a fair amount of hairy stuff to do with letting the main + * check process when a subprocess has failed. Best not to look at it + * and let it do its thing. + * To add new tests, duplicate a set of tests, eg the *_end_of_stream + * ones, and s/_end_of_stream/new_test_name/g. Then do the same for + * the functions they pass as parameters to test_base. Typically, the + * source creation sets a message hook to catch things like async-done + * messages. Sink creation typically adds a probe to check that events, + * buffers, etc, come through as expected. The two success functions + * check all went well for the source and sink. Note that since all of + * these functions take the same user data structure, and the process + * will fork, writing something from one process will not be reflected + * in the other, so there is usually a subset of data relevant to the + * source, and another to the sink. But some have data relevant to both, + * it depends on the test and what you are doing. + * New tests do not have to use this framework, it just avoids spending + * more time and effort on multi process handling. + */ +static void +test_base (const char *name, TestFeatures features, + void (*run_source) (GstElement *, void *), + void (*setup_sink) (GstElement *, void *), + void (*check_success_source) (void *), + void (*check_success_sink) (void *), + gpointer input_data, gpointer master_data, gpointer slave_data) +{ + GstElement *source = NULL, *asink = NULL, *vsink = NULL; + GstElement *slave_pipeline = NULL; + GstStateChangeReturn ret; + gboolean c_src, c_sink; + pid_t pid = 0; + unsigned char x; + int master_recovery_pid_comm[2] = { -1, -1 }; + test_data td = { input_data, master_data, slave_data, features, FALSE, NULL, + NULL, GST_STATE_NULL + }; + + g_print ("Testing: %s\n", name); + + weak_refs = NULL; + + FAIL_IF (pipe2 (pipesfa, O_NONBLOCK) < 0); + FAIL_IF (pipe2 (pipesba, O_NONBLOCK) < 0); + FAIL_IF (pipe2 (pipesfv, O_NONBLOCK) < 0); + FAIL_IF (pipe2 (pipesbv, O_NONBLOCK) < 0); + FAIL_IF (socketpair (PF_UNIX, SOCK_STREAM, 0, ctlsock) < 0); + + FAIL_IF (pipesfa[0] < 0); + FAIL_IF (pipesfa[1] < 0); + FAIL_IF (pipesba[0] < 0); + FAIL_IF (pipesba[1] < 0); + FAIL_IF (pipesfv[0] < 0); + FAIL_IF (pipesfv[1] < 0); + FAIL_IF (pipesbv[0] < 0); + FAIL_IF (pipesbv[1] < 0); + + gst_debug_remove_log_function (gst_debug_log_default); + + listen_for_unwind (); + child_dead = FALSE; + + if (features & TEST_FEATURE_RECOVERY_MASTER_PROCESS) { + /* the other master will let us know its child's PID so we can unwind + it when we're finished */ + FAIL_IF (pipe2 (master_recovery_pid_comm, O_NONBLOCK) < 0); + + recovery_pid = fork (); + if (recovery_pid > 0) { + /* we're the main process that libcheck waits for */ + die_on_child_death (); + while (!child_dead) + g_usleep (1000); + /* leave some time for the slave to timeout (1 second), record error, etc */ + g_usleep (1500 * 1000); + + /* Discard anything that was sent to the previous process when it died */ + while (read (pipesba[0], &x, 1) == 1); + + FAIL_UNLESS (read (master_recovery_pid_comm[0], &pid, + sizeof (pid)) == sizeof (pid)); + + setup_log ("gstsrc.log", TRUE); + source = create_source (features, pipesba[0], pipesfa[1], pipesbv[0], + pipesfv[1], &td); + FAIL_UNLESS (source); + if (run_source) + run_source (source, &td); + goto setup_done; + } + } + + if (features & TEST_FEATURE_RECOVERY_SLAVE_PROCESS) { + recovery_pid = fork (); + if (!recovery_pid) { + wait_for_recovery (); + + /* Discard anything that was sent to the previous process when it died */ + while (read (pipesfa[0], &x, 1) == 1); + + setup_log ("gstasink.log", TRUE); + asink = create_sink (features, &slave_pipeline, pipesfa[0], pipesba[1], + "audio/x-raw"); + FAIL_UNLESS (asink); + ensure_sink_setup (asink, setup_sink, &td); + ack_recovery (); + goto setup_done; + } + } + + pid = fork (); + FAIL_IF (pid < 0); + if (pid) { + if (features & TEST_FEATURE_RECOVERY_MASTER_PROCESS) { + FAIL_UNLESS (write (master_recovery_pid_comm[1], &pid, + sizeof (pid)) == sizeof (pid)); + } + die_on_child_death (); + if (features & TEST_FEATURE_SPLIT_SINKS) { + pid = fork (); + FAIL_IF (pid < 0); + if (pid) { + die_on_child_death (); + } + c_src = ! !pid; + c_sink = !pid; + } else { + c_src = TRUE; + c_sink = FALSE; + } + if (c_src) { + setup_log ("gstsrc.log", FALSE); + source = create_source (features, pipesba[0], pipesfa[1], pipesbv[0], + pipesfv[1], &td); + FAIL_UNLESS (source); + run_source (source, &td); + } + if (c_sink) { + setup_log ("gstasink.log", FALSE); + asink = create_sink (features, &slave_pipeline, pipesfa[0], pipesba[1], + "audio/x-raw"); + FAIL_UNLESS (asink); + } + } else { + td.two_streams = (features & TEST_FEATURE_HAS_VIDEO) && + !(features & TEST_FEATURE_SPLIT_SINKS); + + if (features & TEST_FEATURE_HAS_VIDEO) { + setup_log ("gstvsink.log", FALSE); + vsink = create_sink (features, &slave_pipeline, pipesfv[0], pipesbv[1], + "video/x-raw"); + FAIL_UNLESS (vsink); + } + if (!(features & TEST_FEATURE_SPLIT_SINKS)) { + setup_log ("gstasink.log", FALSE); + asink = create_sink (features, &slave_pipeline, pipesfa[0], pipesba[1], + "audio/x-raw"); + FAIL_UNLESS (asink); + } + } + +setup_done: + ensure_sink_setup (asink, setup_sink, &td); + ensure_sink_setup (vsink, setup_sink, &td); + + loop = g_main_loop_new (NULL, FALSE); + g_main_loop_run (loop); + + /* tell the child process to unwind too */ + stop_listening_for_unwind (); + + if (source) { + ret = gst_element_set_state (source, GST_STATE_NULL); + FAIL_UNLESS (ret == GST_STATE_CHANGE_SUCCESS + || ret == GST_STATE_CHANGE_ASYNC); + } + + if (pid) + kill (pid, SIGUSR1); + + g_main_loop_unref (loop); + + if (source) { + cleanup_bus (source); + if (check_success_source) + check_success_source (&td); + } else { + if (asink) + cleanup_bus (asink); + if (vsink) + cleanup_bus (vsink); + if (check_success_sink) + check_success_sink (&td); + } + + disconnect_ipcpipeline_elements (); + + close (pipesfa[0]); + close (pipesfa[1]); + close (pipesba[0]); + close (pipesba[1]); + close (pipesfv[0]); + close (pipesfv[1]); + close (pipesbv[0]); + close (pipesbv[1]); + + /* If we have a child, we must now wait for it to be finished. + We can't just waitpid, because this child might be still doing + its shutdown, and might assert, and the die_on_child_death + function will exit with the right exit code if so. So we wait + for the child_dead boolean to be set, which die_on_child_death + sets if the child dies normally. */ + if (pid) { + while (!child_dead) + g_usleep (1000); + } + + if (source) { + FAIL_UNLESS_EQUALS_INT (GST_OBJECT_REFCOUNT_VALUE (source), 1); + gst_object_unref (source); + } + /* asink and vsink may be the same object, so refcount is not sure to be 1 */ + if (asink) + gst_object_unref (asink); + if (vsink) + gst_object_unref (vsink); + + /* cleanup tasks a bit earlier to make sure all weak refs are gone */ + gst_task_cleanup_all (); + + /* all ipcpipeline elements we created should now be destroyed */ + if (weak_refs) { +#if 1 + /* to make it easier to see what leaks */ + GList *l; + for (l = weak_refs; l; l = l->next) { + g_print ("%s has %u refs\n", GST_ELEMENT_NAME (l->data), + GST_OBJECT_REFCOUNT_VALUE (l->data)); + } +#endif + FAIL_UNLESS (0); + } +} + +/**** play-pause test ****/ + +typedef struct +{ + gboolean got_state_changed_to_playing[2]; + gboolean got_state_changed_to_paused; +} play_pause_master_data; + +typedef struct +{ + gboolean got_caps[2]; + gboolean got_segment[2]; + gboolean got_buffer[2]; +} play_pause_slave_data; + +static gboolean +idlenull (gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + ret = gst_element_set_state (td->p, GST_STATE_NULL); + FAIL_UNLESS (ret == GST_STATE_CHANGE_SUCCESS); + gst_object_unref (td->p); + g_main_loop_quit (loop); + return G_SOURCE_REMOVE; +} + +static gboolean idleplay (gpointer user_data); +static gboolean +idlepause (gpointer user_data) +{ + test_data *td = user_data; + play_pause_master_data *d = td->md; + GstStateChangeReturn ret; + + ret = gst_element_set_state (td->p, GST_STATE_PAUSED); + FAIL_IF (ret == GST_STATE_CHANGE_FAILURE); + if (ret == GST_STATE_CHANGE_SUCCESS || ret == GST_STATE_CHANGE_NO_PREROLL) { + /* if the state change is not async, we won't get an aync-done, but + this is expected, so set the flag here */ + d->got_state_changed_to_paused = TRUE; + td->state_target = GST_STATE_PLAYING; + g_timeout_add (STEP_AT, idleplay, user_data); + return G_SOURCE_REMOVE; + } + gst_object_unref (td->p); + return G_SOURCE_REMOVE; +} + +static gboolean +idleplay (gpointer user_data) +{ + test_data *td = user_data; + play_pause_master_data *d = td->md; + GstStateChangeReturn ret; + + ret = gst_element_set_state (td->p, GST_STATE_PLAYING); + FAIL_IF (ret == GST_STATE_CHANGE_FAILURE); + if (ret == GST_STATE_CHANGE_SUCCESS || ret == GST_STATE_CHANGE_NO_PREROLL) { + /* if the state change is not async, we won't get an aync-done, but + this is expected, so set the flag here */ + d->got_state_changed_to_playing[1] = TRUE; + td->state_target = GST_STATE_NULL; + g_timeout_add (STEP_AT, idlenull, user_data); + return G_SOURCE_REMOVE; + } + gst_object_unref (td->p); + return G_SOURCE_REMOVE; +} + +static void +play_pause_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + play_pause_master_data *d = td->md; + GstStateChangeReturn ret; + + if (d->got_state_changed_to_paused) { + d->got_state_changed_to_playing[1] = TRUE; + td->state_target = GST_STATE_NULL; + ret = gst_element_set_state (td->p, GST_STATE_NULL); + FAIL_UNLESS (ret == GST_STATE_CHANGE_SUCCESS); + g_main_loop_quit (loop); + } else if (d->got_state_changed_to_playing[0]) { + d->got_state_changed_to_paused = TRUE; + td->state_target = GST_STATE_PLAYING; + gst_object_ref (td->p); + g_timeout_add (STEP_AT, (GSourceFunc) idleplay, td); + } else { + d->got_state_changed_to_playing[0] = TRUE; + td->state_target = GST_STATE_PAUSED; + gst_object_ref (td->p); + g_timeout_add (STEP_AT, (GSourceFunc) idlepause, td); + } +} + +static void +play_pause_source (GstElement * source, void *user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = play_pause_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static GstPadProbeReturn +play_pause_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + play_pause_slave_data *d = td->sd; + GstCaps *caps; + + if (GST_IS_BUFFER (info->data)) { + d->got_buffer[pad2idx (pad, td->two_streams)] = TRUE; + } else if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_CAPS) { + gst_event_parse_caps (info->data, &caps); + d->got_caps[caps2idx (caps, td->two_streams)] = TRUE; + } else if (GST_EVENT_TYPE (info->data) == GST_EVENT_SEGMENT) { + d->got_segment[pad2idx (pad, td->two_streams)] = TRUE; + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_probe_types (const GValue * sinkv, GstPadProbeCallback probe, + unsigned int types, gpointer user_data) +{ + GstElement *sink; + GstPad *pad; + + sink = g_value_get_object (sinkv); + FAIL_UNLESS (sink); + pad = gst_element_get_static_pad (sink, "sink"); + FAIL_UNLESS (pad); + gst_pad_add_probe (pad, types, probe, user_data, NULL); + gst_object_unref (pad); +} + +static void +hook_probe (const GValue * sinkv, GstPadProbeCallback probe, gpointer user_data) +{ + hook_probe_types (sinkv, probe, + GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM | GST_PAD_PROBE_TYPE_EVENT_FLUSH | + GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM, user_data); +} + +static void +hook_play_pause_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, play_pause_probe, user_data); +} + +static void +setup_sink_play_pause (GstElement * sink, void *user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_play_pause_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_play_pause (void *user_data) +{ + test_data *td = user_data; + play_pause_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing[0]); + FAIL_UNLESS (d->got_state_changed_to_playing[1]); + FAIL_UNLESS (d->got_state_changed_to_paused); +} + +static void +check_success_sink_play_pause (void *user_data) +{ + test_data *td = user_data; + play_pause_slave_data *d = td->sd; + int idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->got_caps[idx]); + FAIL_UNLESS (d->got_segment[idx]); + FAIL_UNLESS (d->got_buffer[idx]); + } +} + +GST_START_TEST (test_empty_play_pause) +{ + play_pause_master_data md = { 0 }; + play_pause_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, play_pause_source, setup_sink_play_pause, + check_success_source_play_pause, check_success_sink_play_pause, NULL, &md, + &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_play_pause) +{ + play_pause_master_data md = { 0 }; + play_pause_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, play_pause_source, setup_sink_play_pause, + check_success_source_play_pause, check_success_sink_play_pause, NULL, &md, + &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_play_pause) +{ + play_pause_master_data md = { 0 }; + play_pause_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, play_pause_source, + setup_sink_play_pause, check_success_source_play_pause, + check_success_sink_play_pause, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_play_pause) +{ + play_pause_master_data md = { 0 }; + play_pause_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + play_pause_source, setup_sink_play_pause, check_success_source_play_pause, + check_success_sink_play_pause, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_play_pause) +{ + play_pause_master_data md = { 0 }; + play_pause_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, play_pause_source, + setup_sink_play_pause, check_success_source_play_pause, + check_success_sink_play_pause, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_play_pause) +{ + play_pause_master_data md = { 0 }; + play_pause_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, play_pause_source, + setup_sink_play_pause, check_success_source_play_pause, + check_success_sink_play_pause, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_play_pause) +{ + play_pause_master_data md = { 0 }; + play_pause_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + play_pause_source, setup_sink_play_pause, check_success_source_play_pause, + check_success_sink_play_pause, NULL, &md, &sd); +} + +GST_END_TEST; + +/**** flushing seek test ****/ + +typedef struct +{ + gboolean segment_seek; + gboolean pause; +} flushing_seek_input_data; + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean got_segment_done; + gboolean seek_sent; +} flushing_seek_master_data; + +typedef struct +{ + GstClockTime first_ts[2]; + gboolean got_caps[2]; + gboolean got_buffer_before_seek[2]; + gboolean got_buffer_after_seek[2]; + gboolean first_buffer_after_seek_has_timestamp_0[2]; + gboolean got_segment_after_seek[2]; + gboolean got_flush_start[2]; + gboolean got_flush_stop[2]; +} flushing_seek_slave_data; + +static gboolean +send_flushing_seek (gpointer user_data) +{ + test_data *td = user_data; + const flushing_seek_input_data *i = td->id; + flushing_seek_master_data *d = td->md; + GstEvent *seek_event; + + if (i->segment_seek) { + GST_INFO_OBJECT (td->p, "Sending segment seek"); + seek_event = + gst_event_new_seek (1.0, GST_FORMAT_TIME, + GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, 0, + GST_SEEK_TYPE_SET, 1 * GST_SECOND); + FAIL_UNLESS (gst_element_send_event (td->p, seek_event)); + } else { + GST_INFO_OBJECT (td->p, "Sending flushing seek"); + gst_element_seek_simple (td->p, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, 0); + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, + gst_object_ref (td->p)); + } + d->seek_sent = TRUE; + return G_SOURCE_REMOVE; +} + +static gboolean +pause_before_seek (gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + ret = gst_element_set_state (td->p, GST_STATE_PAUSED); + FAIL_IF (ret == GST_STATE_CHANGE_FAILURE); + + return G_SOURCE_REMOVE; +} + +static gboolean +flushing_seek_bus_msg (GstBus * bus, GstMessage * message, gpointer user_data) +{ + test_data *td = user_data; + flushing_seek_master_data *d = td->md; + + if (GST_IS_PIPELINE (GST_MESSAGE_SRC (message))) { + if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_SEGMENT_DONE) { + d->got_segment_done = TRUE; + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, + gst_object_ref (td->p)); + } + } + return master_bus_msg (bus, message, user_data); +} + +static void +flushing_seek_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + const flushing_seek_input_data *i = td->id; + flushing_seek_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + if (i->pause) + g_timeout_add (PAUSE_AT, (GSourceFunc) pause_before_seek, td); + g_timeout_add (SEEK_AT, (GSourceFunc) send_flushing_seek, td); + } +} + +static void +flushing_seek_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + /* we're on the source, there's already the basic master_bus_msg watch, + and gst doesn't want more than one watch, so we remove the watch and + call it directly when done in the new watch */ + gst_bus_remove_watch (GST_ELEMENT_BUS (source)); + gst_bus_add_watch (GST_ELEMENT_BUS (source), flushing_seek_bus_msg, + user_data); + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = flushing_seek_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static GstPadProbeReturn +flushing_seek_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + flushing_seek_slave_data *d = td->sd; + GstClockTime ts; + int idx; + GstCaps *caps; + + if (GST_IS_BUFFER (info->data)) { + idx = pad2idx (pad, td->two_streams); + if (d->got_flush_stop[idx]) { + if (!d->got_buffer_after_seek[idx]) { + ts = GST_BUFFER_TIMESTAMP (info->data); + d->first_buffer_after_seek_has_timestamp_0[idx] = + (ts < d->first_ts[idx] + 10 * GST_MSECOND); + d->got_buffer_after_seek[idx] = TRUE; + } + } else if (!d->got_buffer_before_seek[idx]) { + d->got_buffer_before_seek[idx] = TRUE; + d->first_ts[idx] = GST_BUFFER_TIMESTAMP (info->data); + } + } else if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_CAPS) { + gst_event_parse_caps (info->data, &caps); + if (are_caps_audio (caps) || are_caps_video (caps)) { + idx = caps2idx (caps, td->two_streams); + d->got_caps[idx] = TRUE; + } + } else if (GST_EVENT_TYPE (info->data) == GST_EVENT_SEGMENT) { + /* from the sink pipeline, we don't know whether the master issued a seek, + as the seek_sent memory location isn't directly accesible to us, so we + look for a segment after a buffer to mean a seek was sent */ + idx = pad2idx (pad, td->two_streams); + if (d->got_buffer_before_seek[idx]) + d->got_segment_after_seek[idx] = TRUE; + } else if (GST_EVENT_TYPE (info->data) == GST_EVENT_FLUSH_START) { + idx = pad2idx (pad, td->two_streams); + d->got_flush_start[idx] = TRUE; + } else if (GST_EVENT_TYPE (info->data) == GST_EVENT_FLUSH_STOP) { + idx = pad2idx (pad, td->two_streams); + if (d->got_buffer_before_seek[idx]) + d->got_flush_stop[idx] = TRUE; + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_flushing_seek_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, flushing_seek_probe, user_data); +} + +static void +setup_sink_flushing_seek (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_flushing_seek_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_flushing_seek (gpointer user_data) +{ + test_data *td = user_data; + const flushing_seek_input_data *i = td->id; + flushing_seek_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); + FAIL_UNLESS (d->seek_sent); + FAIL_UNLESS (d->got_segment_done == i->segment_seek); +} + +static void +check_success_sink_flushing_seek (gpointer user_data) +{ + test_data *td = user_data; + flushing_seek_slave_data *d = td->sd; + gint idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->got_caps[idx]); + FAIL_UNLESS (d->got_buffer_before_seek[idx]); + FAIL_UNLESS (d->got_buffer_after_seek[idx]); + FAIL_UNLESS (d->got_segment_after_seek[idx]); + FAIL_UNLESS (d->got_flush_start[idx]); + FAIL_UNLESS (d->got_flush_stop[idx]); + FAIL_UNLESS (d->first_buffer_after_seek_has_timestamp_0[idx]); + } +} + +GST_START_TEST (test_empty_flushing_seek) +{ + flushing_seek_input_data id = { FALSE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_flushing_seek) +{ + flushing_seek_input_data id = { FALSE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_flushing_seek) +{ + flushing_seek_input_data id = { FALSE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_flushing_seek) +{ + flushing_seek_input_data id = { FALSE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + flushing_seek_source, setup_sink_flushing_seek, + check_success_source_flushing_seek, check_success_sink_flushing_seek, &id, + &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_flushing_seek) +{ + flushing_seek_input_data id = { FALSE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_flushing_seek) +{ + flushing_seek_input_data id = { FALSE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_flushing_seek) +{ + flushing_seek_input_data id = { FALSE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + flushing_seek_source, setup_sink_flushing_seek, + check_success_source_flushing_seek, check_success_sink_flushing_seek, &id, + &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_empty_flushing_seek_in_pause) +{ + flushing_seek_input_data id = { FALSE, TRUE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_flushing_seek_in_pause) +{ + flushing_seek_input_data id = { FALSE, TRUE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_flushing_seek_in_pause) +{ + flushing_seek_input_data id = { FALSE, TRUE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_flushing_seek_in_pause) +{ + flushing_seek_input_data id = { FALSE, TRUE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + flushing_seek_source, setup_sink_flushing_seek, + check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_empty_segment_seek) +{ + flushing_seek_input_data id = { TRUE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_segment_seek) +{ + flushing_seek_input_data id = { TRUE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, flushing_seek_source, + setup_sink_flushing_seek, check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_segment_seek) +{ + flushing_seek_input_data id = { TRUE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, + flushing_seek_source, setup_sink_flushing_seek, + check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_segment_seek) +{ + flushing_seek_input_data id = { TRUE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, + flushing_seek_source, setup_sink_flushing_seek, + check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_segment_seek) +{ + flushing_seek_input_data id = { TRUE, FALSE }; + flushing_seek_master_data md = { 0 }; + flushing_seek_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + flushing_seek_source, setup_sink_flushing_seek, + check_success_source_flushing_seek, + check_success_sink_flushing_seek, &id, &md, &sd); +} + +GST_END_TEST; + +/**** seek stress test ****/ + +typedef struct +{ + gint n_flushing_seeks; + gint n_paused_seeks; + gint n_segment_seeks; +} seek_stress_input_data; + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean got_eos; + gboolean seek_sent; + guint64 t0; +} seek_stress_master_data; + +static gboolean +send_seek_stress (gpointer user_data) +{ + test_data *td = user_data; + seek_stress_input_data *i = td->id; + seek_stress_master_data *d = td->md; + GstEvent *seek_event; + unsigned int available, seekidx; + GstClockTime t, base; + + /* Live streams don't like to be seeked too far away from the + "current" time, since they're live, so always seek near the + "real" time, so we still exercise seeking to another position + but still land somewhere close enough to "live" position. */ + t = (g_get_monotonic_time () - d->t0) * 1000; + base = t > GST_SECOND / 2 ? t - GST_SECOND / 2 : 0; + t = base + g_random_int_range (0, GST_SECOND); + + /* pick a random seek type among the ones we have left */ + available = i->n_flushing_seeks + i->n_paused_seeks + i->n_segment_seeks; + if (available == 0) { + GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (td->p), + GST_DEBUG_GRAPH_SHOW_ALL, "inter.test.toplaying"); + FAIL_UNLESS (gst_element_set_state (td->p, + GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE); + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, + gst_object_ref (td->p)); + gst_object_unref (td->p); + return G_SOURCE_REMOVE; + } + + seekidx = rand () % available; + if (seekidx < i->n_flushing_seeks) { + GST_INFO_OBJECT (td->p, "Sending flushing seek to %" GST_TIME_FORMAT, + GST_TIME_ARGS (t)); + FAIL_UNLESS (gst_element_set_state (td->p, + GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE); + FAIL_UNLESS (gst_element_seek_simple (td->p, GST_FORMAT_TIME, + GST_SEEK_FLAG_FLUSH, t)); + --i->n_flushing_seeks; + return G_SOURCE_CONTINUE; + } + seekidx -= i->n_flushing_seeks; + + if (seekidx < i->n_paused_seeks) { + GST_INFO_OBJECT (td->p, + "Sending flushing seek in paused to %" GST_TIME_FORMAT, + GST_TIME_ARGS (t)); + FAIL_UNLESS (gst_element_set_state (td->p, + GST_STATE_PAUSED) != GST_STATE_CHANGE_FAILURE); + FAIL_UNLESS (gst_element_seek_simple (td->p, GST_FORMAT_TIME, + GST_SEEK_FLAG_FLUSH, t)); + --i->n_paused_seeks; + return G_SOURCE_CONTINUE; + } + seekidx -= i->n_paused_seeks; + + GST_INFO_OBJECT (td->p, "Sending segment seek to %" GST_TIME_FORMAT, + GST_TIME_ARGS (t)); + seek_event = + gst_event_new_seek (1.0, GST_FORMAT_TIME, + GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, t, + GST_SEEK_TYPE_SET, t + 5 * GST_SECOND); + FAIL_UNLESS (gst_element_send_event (td->p, seek_event)); + --i->n_segment_seeks; + return G_SOURCE_CONTINUE; +} + +static gboolean +seek_stress_bus_msg (GstBus * bus, GstMessage * message, gpointer user_data) +{ + test_data *td = user_data; + seek_stress_master_data *d = td->md; + + if (GST_IS_PIPELINE (GST_MESSAGE_SRC (message))) { + if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_EOS || + GST_MESSAGE_TYPE (message) == GST_MESSAGE_SEGMENT_DONE) { + d->got_eos = TRUE; + } + } + return master_bus_msg (bus, message, user_data); +} + +static void +seek_stress_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + seek_stress_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + d->t0 = g_get_monotonic_time (); + gst_object_ref (td->p); + g_timeout_add (10, (GSourceFunc) send_seek_stress, td); + } +} + +static void +seek_stress_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + /* we're on the source, there's already the basic master_bus_msg watch, + and gst doesn't want more than one watch, so we remove the watch and + call it directly when done in the new watch */ + gst_bus_remove_watch (GST_ELEMENT_BUS (source)); + gst_bus_add_watch (GST_ELEMENT_BUS (source), seek_stress_bus_msg, user_data); + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = seek_stress_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static void +check_success_source_seek_stress (gpointer user_data) +{ + test_data *td = user_data; + seek_stress_input_data *i = td->id; + seek_stress_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); + FAIL_UNLESS_EQUALS_INT (i->n_flushing_seeks, 0); + FAIL_UNLESS_EQUALS_INT (i->n_paused_seeks, 0); + FAIL_UNLESS_EQUALS_INT (i->n_segment_seeks, 0); + FAIL_IF (d->got_eos); +} + +GST_START_TEST (test_empty_seek_stress) +{ + seek_stress_input_data id = { 100, 100, 100 }; + seek_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, seek_stress_source, NULL, + check_success_source_seek_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_seek_stress) +{ + seek_stress_input_data id = { 100, 100, 100 }; + seek_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, seek_stress_source, NULL, + check_success_source_seek_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_seek_stress) +{ + seek_stress_input_data id = { 100, 100, 0 }; + seek_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, seek_stress_source, NULL, + check_success_source_seek_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_seek_stress) +{ + seek_stress_input_data id = { 100, 100, 0 }; + seek_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + seek_stress_source, NULL, check_success_source_seek_stress, NULL, &id, + &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_seek_stress) +{ + seek_stress_input_data id = { 100, 0, 100 }; + seek_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE | TEST_FEATURE_LONG_DURATION, + seek_stress_source, NULL, check_success_source_seek_stress, NULL, &id, + &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_seek_stress) +{ + seek_stress_input_data id = { 100, 0, 100 }; + seek_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_LONG_DURATION, + seek_stress_source, NULL, check_success_source_seek_stress, NULL, &id, + &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_seek_stress) +{ + seek_stress_input_data id = { 100, 0, 100 }; + seek_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_LONG_DURATION | + TEST_FEATURE_SPLIT_SINKS, + seek_stress_source, NULL, check_success_source_seek_stress, NULL, &id, + &md, NULL); +} + +GST_END_TEST; + +/**** upstream query test ****/ + +typedef struct +{ + GstClockTime expected_duration; + + /* In this test, the source does a position query (in the source pipeline + process), and must check its return against the last buffer timestamp + in the sink pipeline process. We open a pipe to let the sink send us + the timestamps it receives so the source can make the comparison. */ + gint ts_pipes[2]; +} upstream_query_input_data; + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean got_correct_position; + gboolean got_correct_duration; + GstClockTime last_buffer_ts; +} upstream_query_master_data; + +typedef struct +{ + gboolean got_caps[2]; + gboolean got_buffer[2]; + GstClockTime last_buffer_ts; +} upstream_query_slave_data; + +static gboolean +send_upstream_queries (gpointer user_data) +{ + test_data *td = user_data; + upstream_query_input_data *i = td->id; + upstream_query_master_data *d = td->md; + gint64 pos, dur, last; + + FAIL_UNLESS (gst_element_query_position (td->p, GST_FORMAT_TIME, &pos)); + + /* read up the buffer ts sent by the sink process till the last one */ + while (read (i->ts_pipes[0], &last, sizeof (last)) == sizeof (last)) { + /* timestamps may not be increasing because we are getting ts from + * both the audio and video streams; the position query will report + * the higher */ + if (last > d->last_buffer_ts) + d->last_buffer_ts = last; + } + if (ABS ((gint64) (pos - d->last_buffer_ts)) <= CLOSE_ENOUGH_TO_ZERO) + d->got_correct_position = TRUE; + + FAIL_UNLESS (gst_element_query_duration (td->p, GST_FORMAT_TIME, &dur)); + if (GST_CLOCK_TIME_IS_VALID (i->expected_duration)) { + GstClockTimeDiff diff = GST_CLOCK_DIFF (dur, i->expected_duration); + if (diff >= -CLOSE_ENOUGH_TO_ZERO && diff <= CLOSE_ENOUGH_TO_ZERO) + d->got_correct_duration = TRUE; + } else { + if (!GST_CLOCK_TIME_IS_VALID (dur)) + d->got_correct_duration = TRUE; + } + + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, td->p); + return FALSE; +} + +static void +upstream_query_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + upstream_query_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + gst_object_ref (td->p); + g_timeout_add (QUERY_AT, (GSourceFunc) send_upstream_queries, td); + } +} + +static void +upstream_query_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_changed_cb = upstream_query_on_state_changed; + td->state_target = GST_STATE_PLAYING; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static GstPadProbeReturn +upstream_query_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + upstream_query_input_data *i = td->id; + upstream_query_slave_data *d = td->sd; + GstCaps *caps; + + if (GST_IS_BUFFER (info->data)) { + d->got_buffer[pad2idx (pad, td->two_streams)] = TRUE; + if (GST_BUFFER_TIMESTAMP_IS_VALID (info->data)) { + d->last_buffer_ts = GST_BUFFER_TIMESTAMP (info->data); + FAIL_UNLESS (write (i->ts_pipes[1], &d->last_buffer_ts, + sizeof (d->last_buffer_ts)) == sizeof (d->last_buffer_ts)); + } + } else if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_CAPS) { + gst_event_parse_caps (info->data, &caps); + d->got_caps[caps2idx (caps, td->two_streams)] = TRUE; + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_upstream_query_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, upstream_query_probe, user_data); +} + +static void +setup_sink_upstream_query (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_upstream_query_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_upstream_query (gpointer user_data) +{ + test_data *td = user_data; + upstream_query_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); + FAIL_UNLESS (d->got_correct_position); + FAIL_UNLESS (d->got_correct_duration); +} + +static void +check_success_sink_upstream_query (gpointer user_data) +{ + test_data *td = user_data; + upstream_query_slave_data *d = td->sd; + int idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); ++idx) { + FAIL_UNLESS (d->got_caps[idx]); + FAIL_UNLESS (d->got_buffer[idx]); + } +} + +GST_START_TEST (test_empty_upstream_query) +{ + upstream_query_input_data id = { GST_CLOCK_TIME_NONE, }; + upstream_query_master_data md = { 0 }; + upstream_query_slave_data sd = { 0 }; + + FAIL_UNLESS (pipe2 (id.ts_pipes, O_NONBLOCK) == 0); + TEST_BASE (TEST_FEATURE_TEST_SOURCE, upstream_query_source, + setup_sink_upstream_query, check_success_source_upstream_query, + check_success_sink_upstream_query, &id, &md, &sd); + close (id.ts_pipes[0]); + close (id.ts_pipes[1]); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_upstream_query) +{ + upstream_query_input_data id = { WAV_SAMPLE_ROUGH_DURATION, }; + upstream_query_master_data md = { 0 }; + upstream_query_slave_data sd = { 0 }; + + FAIL_UNLESS (pipe2 (id.ts_pipes, O_NONBLOCK) == 0); + TEST_BASE (TEST_FEATURE_WAV_SOURCE, upstream_query_source, + setup_sink_upstream_query, check_success_source_upstream_query, + check_success_sink_upstream_query, &id, &md, &sd); + close (id.ts_pipes[0]); + close (id.ts_pipes[1]); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_upstream_query) +{ + upstream_query_input_data id = { MPEGTS_SAMPLE_ROUGH_DURATION, }; + upstream_query_master_data md = { 0 }; + upstream_query_slave_data sd = { 0 }; + + FAIL_UNLESS (pipe2 (id.ts_pipes, O_NONBLOCK) == 0); + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, upstream_query_source, + setup_sink_upstream_query, check_success_source_upstream_query, + check_success_sink_upstream_query, &id, &md, &sd); + close (id.ts_pipes[0]); + close (id.ts_pipes[1]); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_upstream_query) +{ + upstream_query_input_data id = { MPEGTS_SAMPLE_ROUGH_DURATION, }; + upstream_query_master_data md = { 0 }; + upstream_query_slave_data sd = { 0 }; + + FAIL_UNLESS (pipe2 (id.ts_pipes, O_NONBLOCK) == 0); + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + upstream_query_source, setup_sink_upstream_query, + check_success_source_upstream_query, check_success_sink_upstream_query, + &id, &md, &sd); + close (id.ts_pipes[0]); + close (id.ts_pipes[1]); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_upstream_query) +{ + upstream_query_input_data id = { GST_CLOCK_TIME_NONE, }; + upstream_query_master_data md = { 0 }; + upstream_query_slave_data sd = { 0 }; + + FAIL_UNLESS (pipe2 (id.ts_pipes, O_NONBLOCK) == 0); + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, + upstream_query_source, setup_sink_upstream_query, + check_success_source_upstream_query, check_success_sink_upstream_query, + &id, &md, &sd); + close (id.ts_pipes[0]); + close (id.ts_pipes[1]); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_upstream_query) +{ + upstream_query_input_data id = { GST_CLOCK_TIME_NONE, }; + upstream_query_master_data md = { 0 }; + upstream_query_slave_data sd = { 0 }; + + FAIL_UNLESS (pipe2 (id.ts_pipes, O_NONBLOCK) == 0); + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, + upstream_query_source, setup_sink_upstream_query, + check_success_source_upstream_query, check_success_sink_upstream_query, + &id, &md, &sd); + close (id.ts_pipes[0]); + close (id.ts_pipes[1]); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_upstream_query) +{ + upstream_query_input_data id = { GST_CLOCK_TIME_NONE, }; + upstream_query_master_data md = { 0 }; + upstream_query_slave_data sd = { 0 }; + + FAIL_UNLESS (pipe2 (id.ts_pipes, O_NONBLOCK) == 0); + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + upstream_query_source, setup_sink_upstream_query, + check_success_source_upstream_query, check_success_sink_upstream_query, + &id, &md, &sd); + close (id.ts_pipes[0]); + close (id.ts_pipes[1]); +} + +GST_END_TEST; + +/**** message test ****/ + +typedef struct +{ + gboolean got_state_changed_to_playing; + guint8 num_got_message; + guint8 num_sent_message; +} message_master_data; + +static void +send_ipcpipeline_test_message_event (const GValue * v, gpointer user_data) +{ + test_data *td = user_data; + message_master_data *d = td->md; + GstElement *element = g_value_get_object (v); + GstMessage *msg; + gboolean ret; + + d->num_sent_message++; + + msg = gst_message_new_element (GST_OBJECT (element), + gst_structure_new_empty ("ipcpipeline-test")); + ret = gst_element_send_event (element, + gst_event_new_sink_message ("ipcpipeline-test", msg)); + FAIL_UNLESS (ret); + gst_message_unref (msg); +} + +static gboolean +send_sink_message (gpointer user_data) +{ + test_data *td = user_data; + GstIterator *it; + + it = gst_bin_iterate_sources (GST_BIN (td->p)); + while (gst_iterator_foreach (it, send_ipcpipeline_test_message_event, td)) + gst_iterator_resync (it); + gst_iterator_free (it); + + gst_object_unref (td->p); + return G_SOURCE_REMOVE; +} + +static gboolean +message_bus_msg (GstBus * bus, GstMessage * message, gpointer user_data) +{ + test_data *td = user_data; + message_master_data *d = td->md; + const GstStructure *structure; + + if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT) { + structure = gst_message_get_structure (message); + FAIL_UNLESS (structure); + if (gst_structure_has_name (structure, "ipcpipeline-test")) { + d->num_got_message++; + if (d->num_got_message == d->num_sent_message) + g_main_loop_quit (loop); + } + } + return master_bus_msg (bus, message, user_data); +} + +static void +message_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + message_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + gst_object_ref (td->p); + g_timeout_add (MESSAGE_AT, (GSourceFunc) send_sink_message, td); + } +} + +static void +message_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + /* we're on the source, there's already the basic master_bus_msg watch, + and gst doesn't want more than one watch, so we remove the watch and + call it directly when done in the new watch */ + gst_bus_remove_watch (GST_ELEMENT_BUS (source)); + gst_bus_add_watch (GST_ELEMENT_BUS (source), message_bus_msg, user_data); + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = message_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static void +check_success_source_message (gpointer user_data) +{ + test_data *td = user_data; + message_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); + FAIL_UNLESS_EQUALS_INT (d->num_got_message, d->num_sent_message); +} + +GST_START_TEST (test_empty_message) +{ + message_master_data md = { 0 }; + TEST_BASE (TEST_FEATURE_TEST_SOURCE, message_source, NULL, + check_success_source_message, NULL, NULL, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_message) +{ + message_master_data md = { 0 }; + TEST_BASE (TEST_FEATURE_WAV_SOURCE, message_source, NULL, + check_success_source_message, NULL, NULL, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_message) +{ + message_master_data md = { 0 }; + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, message_source, NULL, + check_success_source_message, NULL, NULL, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_message) +{ + message_master_data md = { 0 }; + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, message_source, NULL, + check_success_source_message, NULL, NULL, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_message) +{ + message_master_data md = { 0 }; + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + message_source, NULL, check_success_source_message, NULL, NULL, &md, + NULL); +} + +GST_END_TEST; + +/**** end of stream test ****/ + +typedef struct +{ + gboolean got_state_changed_to_playing; +} end_of_stream_master_data; + +typedef struct +{ + gboolean got_buffer[2]; + gboolean got_eos[2]; +} end_of_stream_slave_data; + +static void +end_of_stream_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + end_of_stream_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) + d->got_state_changed_to_playing = TRUE; +} + +static void +end_of_stream_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_changed_cb = end_of_stream_on_state_changed; + td->state_target = GST_STATE_PLAYING; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static GstPadProbeReturn +end_of_stream_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + end_of_stream_slave_data *d = td->sd; + + if (GST_IS_BUFFER (info->data)) { + d->got_buffer[pad2idx (pad, td->two_streams)] = TRUE; + } else if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_EOS) { + d->got_eos[pad2idx (pad, td->two_streams)] = TRUE; + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_end_of_stream_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, end_of_stream_probe, user_data); +} + +static void +setup_sink_end_of_stream (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_end_of_stream_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_end_of_stream (gpointer user_data) +{ + test_data *td = user_data; + end_of_stream_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); +} + +static void +check_success_sink_end_of_stream (gpointer user_data) +{ + test_data *td = user_data; + end_of_stream_slave_data *d = td->sd; + int idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->got_buffer[idx]); + FAIL_UNLESS (d->got_eos[idx]); + } +} + +GST_START_TEST (test_empty_end_of_stream) +{ + end_of_stream_master_data md = { 0 }; + end_of_stream_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_ASYNC_SINK, + end_of_stream_source, setup_sink_end_of_stream, + check_success_source_end_of_stream, check_success_sink_end_of_stream, + NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_end_of_stream) +{ + end_of_stream_master_data md = { 0 }; + end_of_stream_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE | TEST_FEATURE_ASYNC_SINK, + end_of_stream_source, setup_sink_end_of_stream, + check_success_source_end_of_stream, check_success_sink_end_of_stream, + NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_end_of_stream) +{ + end_of_stream_master_data md = { 0 }; + end_of_stream_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_ASYNC_SINK, + end_of_stream_source, setup_sink_end_of_stream, + check_success_source_end_of_stream, check_success_sink_end_of_stream, + NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_end_of_stream) +{ + end_of_stream_master_data md = { 0 }; + end_of_stream_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS | + TEST_FEATURE_ASYNC_SINK, + end_of_stream_source, setup_sink_end_of_stream, + check_success_source_end_of_stream, check_success_sink_end_of_stream, + NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_end_of_stream) +{ + end_of_stream_master_data md = { 0 }; + end_of_stream_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, + end_of_stream_source, setup_sink_end_of_stream, + check_success_source_end_of_stream, check_success_sink_end_of_stream, + NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_end_of_stream) +{ + end_of_stream_master_data md = { 0 }; + end_of_stream_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, + end_of_stream_source, setup_sink_end_of_stream, + check_success_source_end_of_stream, check_success_sink_end_of_stream, + NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_end_of_stream) +{ + end_of_stream_master_data md = { 0 }; + end_of_stream_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + end_of_stream_source, setup_sink_end_of_stream, + check_success_source_end_of_stream, check_success_sink_end_of_stream, + NULL, &md, &sd); +} + +GST_END_TEST; + +/**** reverse playback test ****/ + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean seek_sent; +} reverse_playback_master_data; + +typedef struct +{ + gboolean got_segment_with_negative_rate; + gboolean got_buffer_after_segment_with_negative_rate; + GstClockTime first_backward_buffer_timestamp; + gboolean got_buffer_one_second_early; +} reverse_playback_slave_data; + +static gboolean +play_backwards (gpointer user_data) +{ + test_data *td = user_data; + reverse_playback_master_data *d = td->md; + gint64 pos; + gboolean ret; + + FAIL_UNLESS (gst_element_query_position (td->p, GST_FORMAT_TIME, &pos)); + + ret = + gst_element_seek (td->p, -0.5, GST_FORMAT_TIME, 0, GST_SEEK_TYPE_SET, 0, + GST_SEEK_TYPE_SET, pos); + FAIL_UNLESS (ret); + d->seek_sent = TRUE; + + gst_object_unref (td->p); + return G_SOURCE_REMOVE; +} + +static void +reverse_playback_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + reverse_playback_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + gst_object_ref (td->p); + g_timeout_add (2000, (GSourceFunc) play_backwards, td); + } +} + +static void +reverse_playback_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = reverse_playback_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static GstPadProbeReturn +reverse_playback_probe (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + reverse_playback_slave_data *d = td->sd; + + if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_SEGMENT) { + const GstSegment *s; + gst_event_parse_segment (GST_EVENT (info->data), &s); + if (s->rate < 0) + d->got_segment_with_negative_rate = TRUE; + } + } else if (GST_IS_BUFFER (info->data)) { + GstClockTime ts = GST_BUFFER_TIMESTAMP (info->data); + if (GST_CLOCK_TIME_IS_VALID (ts)) { + if (d->got_segment_with_negative_rate) { + if (d->got_buffer_after_segment_with_negative_rate) { + /* We test for 1 second, not just earlier, to make sure we don't + just see B frames, or whatever else */ + if (ts < d->first_backward_buffer_timestamp - GST_SECOND) { + d->got_buffer_one_second_early = TRUE; + } + } else { + d->got_buffer_after_segment_with_negative_rate = TRUE; + d->first_backward_buffer_timestamp = ts; + } + } + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_reverse_playback_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, reverse_playback_probe, user_data); +} + +static void +setup_sink_reverse_playback (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_reverse_playback_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_reverse_playback (gpointer user_data) +{ + test_data *td = user_data; + reverse_playback_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); + FAIL_UNLESS (d->seek_sent); +} + +static void +check_success_sink_reverse_playback (gpointer user_data) +{ + test_data *td = user_data; + reverse_playback_slave_data *d = td->sd; + + FAIL_UNLESS (d->got_segment_with_negative_rate); + FAIL_UNLESS (d->got_buffer_after_segment_with_negative_rate); + FAIL_UNLESS (GST_CLOCK_TIME_IS_VALID (d->first_backward_buffer_timestamp)); + FAIL_UNLESS (d->first_backward_buffer_timestamp >= GST_SECOND); + FAIL_UNLESS (d->got_buffer_one_second_early); +} + +GST_START_TEST (test_a_reverse_playback) +{ + reverse_playback_master_data md = { 0 }; + reverse_playback_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, + reverse_playback_source, setup_sink_reverse_playback, + check_success_source_reverse_playback, + check_success_sink_reverse_playback, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_av_reverse_playback) +{ + reverse_playback_master_data md = { 0 }; + reverse_playback_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_HAS_VIDEO, + reverse_playback_source, setup_sink_reverse_playback, + check_success_source_reverse_playback, + check_success_sink_reverse_playback, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_av_2_reverse_playback) +{ + reverse_playback_master_data md = { 0 }; + reverse_playback_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_HAS_VIDEO | + TEST_FEATURE_SPLIT_SINKS, + reverse_playback_source, setup_sink_reverse_playback, + check_success_source_reverse_playback, + check_success_sink_reverse_playback, NULL, &md, &sd); +} + +GST_END_TEST; + +/**** tags test ****/ + +enum +{ + TEST_TAG_EMPTY, + TEST_TAG_TWO_TAGS, + N_TEST_TAGS +}; + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean tags_sent[N_TEST_TAGS]; +} tags_master_data; + +typedef struct +{ + gboolean tags_received[N_TEST_TAGS]; +} tags_slave_data; + +static void +send_tags_on_element (const GValue * v, gpointer user_data) +{ + test_data *td = user_data; + tags_master_data *d = td->md; + GstElement *sink; + GstPad *pad; + GstEvent *e; + + sink = g_value_get_object (v); + FAIL_UNLESS (sink); + pad = gst_element_get_static_pad (sink, "sink"); + FAIL_UNLESS (pad); + + e = gst_event_new_tag (gst_tag_list_new_empty ()); + FAIL_UNLESS (gst_pad_send_event (pad, e)); + d->tags_sent[TEST_TAG_EMPTY] = TRUE; + + e = gst_event_new_tag (gst_tag_list_new (GST_TAG_TITLE, "title", + GST_TAG_BITRATE, 56000, NULL)); + FAIL_UNLESS (gst_pad_send_event (pad, e)); + d->tags_sent[TEST_TAG_TWO_TAGS] = TRUE; + + gst_object_unref (pad); +} + +static gboolean +send_tags (gpointer user_data) +{ + test_data *td = user_data; + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (td->p)); + while (gst_iterator_foreach (it, send_tags_on_element, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, td->p); + return G_SOURCE_REMOVE; +} + +static void +tags_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + tags_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + gst_object_ref (td->p); + g_timeout_add (STEP_AT, (GSourceFunc) send_tags, td); + } +} + +static void +tags_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = tags_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static GstPadProbeReturn +tags_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + tags_slave_data *d = td->sd; + guint funsigned; + gchar *fstring = NULL; + + if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_TAG) { + GstTagList *taglist = NULL; + gst_event_parse_tag (GST_EVENT (info->data), &taglist); + FAIL_UNLESS (taglist); + if (gst_tag_list_is_empty (taglist)) { + d->tags_received[TEST_TAG_EMPTY] = TRUE; + } else if (gst_tag_list_get_string (taglist, GST_TAG_TITLE, &fstring) + && !strcmp (fstring, "title") + && gst_tag_list_get_uint (taglist, GST_TAG_BITRATE, &funsigned) + && funsigned == 56000) { + d->tags_received[TEST_TAG_TWO_TAGS] = TRUE; + } + } + } + g_free (fstring); + + return GST_PAD_PROBE_OK; +} + +static void +hook_tags_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, tags_probe, user_data); +} + +static void +setup_sink_tags (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_tags_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_tags (gpointer user_data) +{ + test_data *td = user_data; + tags_master_data *d = td->md; + gint n; + + FAIL_UNLESS (d->got_state_changed_to_playing); + for (n = 0; n < N_TEST_TAGS; ++n) { + FAIL_UNLESS (d->tags_sent[n]); + } +} + +static void +check_success_sink_tags (gpointer user_data) +{ + test_data *td = user_data; + tags_slave_data *d = td->sd; + gint n; + + for (n = 0; n < N_TEST_TAGS; ++n) { + FAIL_UNLESS (d->tags_received[n]); + } +} + +GST_START_TEST (test_empty_tags) +{ + tags_master_data md = { 0 }; + tags_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, tags_source, setup_sink_tags, + check_success_source_tags, check_success_sink_tags, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_tags) +{ + tags_master_data md = { 0 }; + tags_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, tags_source, setup_sink_tags, + check_success_source_tags, check_success_sink_tags, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_tags) +{ + tags_master_data md = { 0 }; + tags_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, tags_source, setup_sink_tags, + check_success_source_tags, check_success_sink_tags, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_tags) +{ + tags_master_data md = { 0 }; + tags_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, tags_source, + setup_sink_tags, check_success_source_tags, check_success_sink_tags, NULL, + &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_tags) +{ + tags_master_data md = { 0 }; + tags_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, tags_source, setup_sink_tags, + check_success_source_tags, check_success_sink_tags, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_tags) +{ + tags_master_data md = { 0 }; + tags_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, tags_source, setup_sink_tags, + check_success_source_tags, check_success_sink_tags, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_tags) +{ + tags_master_data md = { 0 }; + tags_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + tags_source, setup_sink_tags, check_success_source_tags, + check_success_sink_tags, NULL, &md, &sd); +} + +GST_END_TEST; + +/**** nagivation test ****/ + +enum +{ + TEST_NAV_MOUSE_MOVE, + TEST_NAV_KEY_PRESS, + N_NAVIGATION_EVENTS +}; + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean navigation_received[N_NAVIGATION_EVENTS]; +} navigation_master_data; + +typedef struct +{ + gboolean started; + gboolean navigation_sent[N_NAVIGATION_EVENTS]; + gint step; +} navigation_slave_data; + +static GstPadProbeReturn +navigation_probe_source (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + navigation_master_data *d = td->md; + const GstStructure *s; + const gchar *string, *key; + double x, y; + + if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_NAVIGATION) { + s = gst_event_get_structure (info->data); + FAIL_UNLESS (s); + + /* mouse-move */ + string = gst_structure_get_string (s, "event"); + if (string && !strcmp (string, "mouse-move")) { + if (gst_structure_get_double (s, "pointer_x", &x) && x == 4.7) { + if (gst_structure_get_double (s, "pointer_y", &y) && y == 0.1) { + d->navigation_received[TEST_NAV_MOUSE_MOVE] = TRUE; + } + } + } + + /* key-press */ + string = gst_structure_get_string (s, "event"); + if (string && !strcmp (string, "key-press")) { + key = gst_structure_get_string (s, "key"); + if (key && !strcmp (key, "Left")) { + d->navigation_received[TEST_NAV_KEY_PRESS] = TRUE; + } + } + + /* drop at this point to imply successful handling; the upstream filesrc + * does not know how to handle navigation events and returns FALSE, + * which makes the test fail */ + return GST_PAD_PROBE_DROP; + } + } + return GST_PAD_PROBE_OK; +} + +static void +hook_navigation_probe_source (const GValue * v, gpointer user_data) +{ + hook_probe_types (v, navigation_probe_source, + GST_PAD_PROBE_TYPE_EVENT_UPSTREAM, user_data); +} + +static void +navigation_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + navigation_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) + d->got_state_changed_to_playing = TRUE; +} + +static void +navigation_source (GstElement * source, void *user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (source)); + while (gst_iterator_foreach (it, hook_navigation_probe_source, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = navigation_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static void +send_navigation_event (const GValue * v, gpointer user_data) +{ + test_data *td = user_data; + navigation_slave_data *d = td->sd; + GstElement *sink; + GstPad *pad, *peer; + GstStructure *s; + GstEvent *e = NULL; + + sink = g_value_get_object (v); + FAIL_UNLESS (sink); + pad = gst_element_get_static_pad (sink, "sink"); + FAIL_UNLESS (pad); + peer = gst_pad_get_peer (pad); + FAIL_UNLESS (peer); + gst_object_unref (pad); + + switch (d->step) { + case TEST_NAV_MOUSE_MOVE: + s = gst_structure_new ("application/x-gst-navigation", "event", + G_TYPE_STRING, "mouse-move", "button", G_TYPE_INT, 0, "pointer_x", + G_TYPE_DOUBLE, 4.7, "pointer_y", G_TYPE_DOUBLE, 0.1, NULL); + e = gst_event_new_navigation (s); + break; + case TEST_NAV_KEY_PRESS: + s = gst_structure_new ("application/x-gst-navigation", "event", + G_TYPE_STRING, "key-press", "key", G_TYPE_STRING, "Left", NULL); + e = gst_event_new_navigation (s); + break; + } + + FAIL_UNLESS (e); + FAIL_UNLESS (gst_pad_send_event (peer, e)); + d->navigation_sent[d->step] = TRUE; + + gst_object_unref (peer); +} + +static gboolean +step_navigation (gpointer user_data) +{ + test_data *td = user_data; + navigation_slave_data *d = td->sd; + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (td->p)); + while (gst_iterator_foreach (it, send_navigation_event, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + if (++d->step < N_NAVIGATION_EVENTS) + return G_SOURCE_CONTINUE; + + /* we are in the slave; send EOS to force the master to stop the pipeline */ + gst_element_post_message (GST_ELEMENT (td->p), + gst_message_new_eos (GST_OBJECT (td->p))); + + gst_object_unref (td->p); + return G_SOURCE_REMOVE; +} + +static GstPadProbeReturn +navigation_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + navigation_slave_data *d = td->sd; + GstClockTime ts; + + if (GST_IS_BUFFER (info->data)) { + ts = GST_BUFFER_TIMESTAMP (info->data); + if (GST_CLOCK_TIME_IS_VALID (ts) && ts > STEP_AT * GST_MSECOND) { + if (!d->started) { + d->started = TRUE; + gst_object_ref (td->p); + g_timeout_add (50, step_navigation, td); + } + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_navigation_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, navigation_probe, user_data); +} + +static void +setup_sink_navigation (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_navigation_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_navigation (gpointer user_data) +{ + test_data *td = user_data; + navigation_master_data *d = td->md; + gint n; + + FAIL_UNLESS (d->got_state_changed_to_playing); + for (n = 0; n < N_NAVIGATION_EVENTS; ++n) { + FAIL_UNLESS (d->navigation_received[n]); + } +} + +static void +check_success_sink_navigation (gpointer user_data) +{ + test_data *td = user_data; + navigation_slave_data *d = td->sd; + gint n; + + FAIL_UNLESS (d->started); + for (n = 0; n < N_NAVIGATION_EVENTS; ++n) { + FAIL_UNLESS (d->navigation_sent[n]); + } +} + +GST_START_TEST (test_non_live_av_navigation) +{ + navigation_master_data md = { 0 }; + navigation_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, navigation_source, + setup_sink_navigation, check_success_source_navigation, + check_success_sink_navigation, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_non_live_av_2_navigation) +{ + navigation_master_data md = { 0 }; + navigation_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + navigation_source, setup_sink_navigation, check_success_source_navigation, + check_success_sink_navigation, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_navigation) +{ + navigation_master_data md = { 0 }; + navigation_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, navigation_source, + setup_sink_navigation, check_success_source_navigation, + check_success_sink_navigation, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_navigation) +{ + navigation_master_data md = { 0 }; + navigation_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + navigation_source, setup_sink_navigation, check_success_source_navigation, + check_success_sink_navigation, NULL, &md, &sd); +} + +GST_END_TEST; + +/**** reconfigure test ****/ + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean reconfigure_sent[2]; +} reconfigure_master_data; + +typedef struct +{ + gboolean reconfigure_scheduled; + gboolean reconfigure_sent[2]; + gboolean got_caps[2][2]; +} reconfigure_slave_data; + +static GstPadProbeReturn +reconfigure_source_probe (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + reconfigure_master_data *d = td->md; + + if (GST_EVENT_TYPE (info->data) == GST_EVENT_RECONFIGURE) { + gint idx = pad2idx (pad, td->two_streams); + d->reconfigure_sent[idx] = TRUE; + if (!td->two_streams || d->reconfigure_sent[idx ? 0 : 1]) { + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, + gst_object_ref (td->p)); + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_reconfigure_source_probe (const GValue * v, gpointer user_data) +{ + hook_probe_types (v, reconfigure_source_probe, + GST_PAD_PROBE_TYPE_EVENT_UPSTREAM, user_data); +} + +static void +reconfigure_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + reconfigure_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) + d->got_state_changed_to_playing = TRUE; +} + +static void +reconfigure_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (source)); + while (gst_iterator_foreach (it, hook_reconfigure_source_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = reconfigure_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static void +send_reconfigure_on_element (const GValue * v, gpointer user_data) +{ + test_data *td = user_data; + reconfigure_slave_data *d = td->sd; + GstElement *sink, *capsfilter; + GstPad *pad, *peer; + GstCaps *caps = NULL; + + sink = g_value_get_object (v); + FAIL_UNLESS (sink); + pad = gst_element_get_static_pad (sink, "sink"); + FAIL_UNLESS (pad); + + // look for the previous element, change caps if a capsfilter + peer = gst_pad_get_peer (pad); + FAIL_UNLESS (peer); + capsfilter = GST_ELEMENT (gst_pad_get_parent (peer)); + g_object_get (capsfilter, "caps", &caps, NULL); + FAIL_UNLESS (caps); + caps = gst_caps_make_writable (caps); + if (!strcmp (gst_structure_get_name (gst_caps_get_structure (caps, 0)), + "audio/x-raw")) { + gst_caps_set_simple (caps, "rate", G_TYPE_INT, 48000, NULL); + } else { + gst_caps_set_simple (caps, "width", G_TYPE_INT, 320, "height", G_TYPE_INT, + 200, NULL); + } + g_object_set (capsfilter, "caps", caps, NULL); + FAIL_UNLESS (capsfilter); + + gst_object_unref (capsfilter); + gst_object_unref (peer); + + d->reconfigure_sent[caps2idx (caps, td->two_streams)] = TRUE; + + gst_caps_unref (caps); + gst_object_unref (pad); +} + +static gboolean +send_reconfigure (gpointer user_data) +{ + test_data *td = user_data; + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (td->p)); + while (gst_iterator_foreach (it, send_reconfigure_on_element, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + gst_object_unref (td->p); + return G_SOURCE_REMOVE; +} + +static GstPadProbeReturn +reconfigure_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + reconfigure_slave_data *d = td->sd; + GstClockTime ts; + GstCaps *caps; + int idx; + + if (GST_IS_BUFFER (info->data)) { + ts = GST_BUFFER_TIMESTAMP (info->data); + if (GST_CLOCK_TIME_IS_VALID (ts) && ts >= STEP_AT * GST_MSECOND) { + if (!d->reconfigure_scheduled) { + d->reconfigure_scheduled = TRUE; + gst_object_ref (td->p); + g_idle_add ((GSourceFunc) send_reconfigure, td); + } + } + } else if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_CAPS) { + gst_event_parse_caps (GST_EVENT (info->data), &caps); + idx = caps2idx (caps, td->two_streams); + if (d->reconfigure_sent[idx]) { + d->got_caps[idx][1] = TRUE; + } else { + d->got_caps[idx][0] = TRUE; + } + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_reconfigure_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, reconfigure_probe, user_data); +} + +static void +setup_sink_reconfigure (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_reconfigure_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_reconfigure (gpointer user_data) +{ + test_data *td = user_data; + reconfigure_master_data *d = td->md; + gint idx; + + FAIL_UNLESS (d->got_state_changed_to_playing); + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->reconfigure_sent[idx]); + } +} + +static void +check_success_sink_reconfigure (gpointer user_data) +{ + test_data *td = user_data; + reconfigure_slave_data *d = td->sd; + gint idx; + + FAIL_UNLESS (d->reconfigure_scheduled); + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->reconfigure_sent[idx]); + FAIL_UNLESS (d->got_caps[idx][0]); + FAIL_UNLESS (d->got_caps[idx][1]); + } +} + +GST_START_TEST (test_non_live_a_reconfigure) +{ + reconfigure_master_data md = { 0 }; + reconfigure_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_FILTER_SINK_CAPS, + reconfigure_source, setup_sink_reconfigure, + check_success_source_reconfigure, check_success_sink_reconfigure, NULL, + &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_non_live_av_reconfigure) +{ + reconfigure_master_data md = { 0 }; + reconfigure_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_HAS_VIDEO | + TEST_FEATURE_FILTER_SINK_CAPS, + reconfigure_source, setup_sink_reconfigure, + check_success_source_reconfigure, check_success_sink_reconfigure, NULL, + &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_reconfigure) +{ + reconfigure_master_data md = { 0 }; + reconfigure_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE | TEST_FEATURE_FILTER_SINK_CAPS, + reconfigure_source, setup_sink_reconfigure, + check_success_source_reconfigure, check_success_sink_reconfigure, NULL, + &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_reconfigure) +{ + reconfigure_master_data md = { 0 }; + reconfigure_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_FILTER_SINK_CAPS, + reconfigure_source, setup_sink_reconfigure, + check_success_source_reconfigure, check_success_sink_reconfigure, NULL, + &md, &sd); +} + +GST_END_TEST; + +/**** state changes test ****/ + +typedef struct +{ + gint step; + GHashTable *fdin, *fdout; + gboolean waiting_state_change; +} state_changes_master_data; + +typedef struct +{ + gint n_null; + gint n_ready; + gint n_paused; + gint n_playing; + gboolean got_eos; + GThread *thread; + gint refcount; +} state_changes_slave_data; + +static void +set_fdin (gpointer key, gpointer value, gpointer user_data) +{ + g_object_set (key, "fdin", GPOINTER_TO_INT (value), NULL); +} + +static void +set_fdout (gpointer key, gpointer value, gpointer user_data) +{ + g_object_set (key, "fdout", GPOINTER_TO_INT (value), NULL); +} + +/* + * NULL + * 0: READY NULL READY PAUSED READY PAUSED READY NULL + * 8: READY PAUSED PLAYING PAUSED PLAYING PAUSED READY PAUSED READY NULL + * 18: disconnect + * 19: READY NULL READY PAUSED READY PAUSED READY NULL + * 27: READY PAUSED PLAYING PAUSED PLAYING PAUSED READY PAUSED READY NULL + * 37: reconnect + * 38: READY NULL READY PAUSED READY PAUSED READY NULL + * 46: READY PAUSED PLAYING PAUSED PLAYING + * 51: EOS + */ +static gboolean +step_state_changes (gpointer user_data) +{ + test_data *td = user_data; + state_changes_master_data *d = td->md; + gboolean ret = G_SOURCE_CONTINUE; + GstStateChangeReturn scret = GST_STATE_CHANGE_FAILURE; + GList *l; + int fdin, fdout; + + if (d->waiting_state_change) + goto done; + + switch (d->step++) { + case 1: + case 7: + case 17: + case 20: + case 26: + case 36: + case 39: + case 45: + scret = gst_element_set_state (td->p, GST_STATE_NULL); + FAIL_UNLESS_EQUALS_INT (scret, GST_STATE_CHANGE_SUCCESS); + break; + case 0: + case 2: + case 4: + case 6: + case 8: + case 14: + case 16: + case 38: + case 40: + case 42: + case 44: + case 46: + scret = gst_element_set_state (td->p, GST_STATE_READY); + FAIL_UNLESS_EQUALS_INT (scret, GST_STATE_CHANGE_SUCCESS); + break; + case 19: + case 21: + case 23: + case 25: + case 27: + case 33: + case 35: + /* while we are disconnected, we can't do NULL -> READY */ + scret = gst_element_set_state (td->p, GST_STATE_READY); + FAIL_UNLESS_EQUALS_INT (scret, GST_STATE_CHANGE_FAILURE); + break; + case 3: + case 5: + case 9: + case 11: + case 13: + case 15: + case 41: + case 43: + case 47: + case 49: + td->state_target = GST_STATE_PAUSED; + scret = gst_element_set_state (td->p, GST_STATE_PAUSED); + FAIL_IF (scret == GST_STATE_CHANGE_FAILURE); + break; + case 22: + case 24: + case 28: + case 30: + case 32: + case 34: + /* while we are disconnected, we can't do NULL -> READY */ + scret = gst_element_set_state (td->p, GST_STATE_PAUSED); + FAIL_UNLESS_EQUALS_INT (scret, GST_STATE_CHANGE_FAILURE); + break; + case 10: + case 12: + case 48: + case 50: + td->state_target = GST_STATE_PLAYING; + scret = gst_element_set_state (td->p, GST_STATE_PLAYING); + FAIL_IF (scret == GST_STATE_CHANGE_FAILURE); + break; + case 29: + case 31: + /* while we are disconnected, we can't do NULL -> READY */ + scret = gst_element_set_state (td->p, GST_STATE_PLAYING); + FAIL_UNLESS_EQUALS_INT (scret, GST_STATE_CHANGE_FAILURE); + break; + case 18: + d->fdin = g_hash_table_new (g_direct_hash, g_direct_equal); + d->fdout = g_hash_table_new (g_direct_hash, g_direct_equal); + for (l = weak_refs; l; l = l->next) { + g_object_get (l->data, "fdin", &fdin, "fdout", &fdout, NULL); + g_hash_table_insert (d->fdin, (gpointer) l->data, + GINT_TO_POINTER (fdin)); + g_hash_table_insert (d->fdout, (gpointer) l->data, + GINT_TO_POINTER (fdout)); + g_signal_emit_by_name (G_OBJECT (l->data), "disconnect", NULL); + } + break; + case 37: + g_hash_table_foreach (d->fdin, set_fdin, NULL); + g_hash_table_foreach (d->fdout, set_fdout, NULL); + g_hash_table_destroy (d->fdin); + g_hash_table_destroy (d->fdout); + break; + case 51: + /* send EOS early to avoid waiting for the actual end of the file */ + gst_element_send_event (td->p, gst_event_new_eos ()); + gst_object_unref (td->p); + ret = G_SOURCE_REMOVE; + break; + } + + if (scret == GST_STATE_CHANGE_ASYNC) + d->waiting_state_change = TRUE; + +done: + return ret; +} + +static void +state_changes_state_changed (gpointer user_data) +{ + test_data *td = user_data; + state_changes_master_data *d = td->md; + + d->waiting_state_change = FALSE; +} + +static void +state_changes_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + state_changes_master_data *d = td->md; + + gst_object_ref (source); + g_timeout_add (STEP_AT, (GSourceFunc) step_state_changes, td); + + d->waiting_state_change = FALSE; + td->state_changed_cb = state_changes_state_changed; +} + +static GstPadProbeReturn +state_changes_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + state_changes_slave_data *d = td->sd; + + if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_EOS) { + d->got_eos = TRUE; + if (g_atomic_int_dec_and_test (&d->refcount)) { + g_thread_join (d->thread); + gst_object_unref (td->p); + } + return GST_PAD_PROBE_REMOVE; + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_state_changes_probe (const GValue * v, gpointer user_data) +{ + test_data *td = user_data; + state_changes_slave_data *d = td->sd; + + d->refcount++; + hook_probe (v, state_changes_probe, user_data); +} + +static gpointer +state_changes_watcher (gpointer user_data) +{ + test_data *td = user_data; + state_changes_slave_data *d = td->sd; + GstState state = GST_STATE_VOID_PENDING, prev_state = GST_STATE_VOID_PENDING; + GstStateChangeReturn ret; + + while (!d->got_eos) { + ret = gst_element_get_state (td->p, &state, NULL, GST_CLOCK_TIME_NONE); + if (ret == GST_STATE_CHANGE_SUCCESS && state != GST_STATE_VOID_PENDING) { + if (state != prev_state) { + switch (state) { + case GST_STATE_NULL: + d->n_null++; + break; + case GST_STATE_READY: + d->n_ready++; + break; + case GST_STATE_PAUSED: + d->n_paused++; + break; + case GST_STATE_PLAYING: + d->n_playing++; + break; + default: + fail_if (1); + } + prev_state = state; + } + } + g_usleep (STEP_AT * 1000 / 4); + } + return NULL; +} + +static void +setup_sink_state_changes (GstElement * sink, gpointer user_data) +{ + test_data *td = user_data; + state_changes_slave_data *d = td->sd; + GstIterator *it; + + gst_object_ref (sink); + d->refcount = 0; + d->thread = + g_thread_new ("state-changes-watcher", + (GThreadFunc) state_changes_watcher, td); + FAIL_UNLESS (d->thread); + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_state_changes_probe, td)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_state_changes (gpointer user_data) +{ + test_data *td = user_data; + state_changes_master_data *d = td->md; + + FAIL_UNLESS_EQUALS_INT (d->step, 52); +} + +static void +check_success_sink_state_changes (gpointer user_data) +{ + test_data *td = user_data; + state_changes_slave_data *d = td->sd; + + FAIL_UNLESS (d->got_eos); + FAIL_UNLESS_EQUALS_INT (d->n_null, 6); + FAIL_UNLESS_EQUALS_INT (d->n_ready, 12); + FAIL_UNLESS_EQUALS_INT (d->n_paused, 10); + FAIL_UNLESS_EQUALS_INT (d->n_playing, 4); +} + +GST_START_TEST (test_empty_state_changes) +{ + state_changes_master_data md = { 0 }; + state_changes_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, state_changes_source, + setup_sink_state_changes, check_success_source_state_changes, + check_success_sink_state_changes, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_state_changes) +{ + state_changes_master_data md = { 0 }; + state_changes_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, state_changes_source, + setup_sink_state_changes, check_success_source_state_changes, + check_success_sink_state_changes, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_state_changes) +{ + state_changes_master_data md = { 0 }; + state_changes_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, state_changes_source, + setup_sink_state_changes, check_success_source_state_changes, + check_success_sink_state_changes, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_state_changes) +{ + state_changes_master_data md = { 0 }; + state_changes_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + state_changes_source, setup_sink_state_changes, + check_success_source_state_changes, check_success_sink_state_changes, + NULL, &md, &sd); +} + +GST_END_TEST; + +/**** state changes stress test ****/ + +typedef struct +{ + gint n_state_changes; +} state_changes_stress_input_data; + +typedef struct +{ + gboolean got_state_changed_to_playing; + gboolean async_state_change_completed; +} state_changes_stress_master_data; + +static gboolean +step_state_changes_stress (gpointer user_data) +{ + test_data *td = user_data; + state_changes_stress_input_data *i = td->id; + state_changes_stress_master_data *d = td->md; + static const GstState states[] = + { GST_STATE_NULL, GST_STATE_READY, GST_STATE_PAUSED, GST_STATE_PLAYING }; + GstState state; + GstStateChangeReturn ret; + + /* wait for async state change to complete before continuing */ + if (!d->async_state_change_completed) + return G_SOURCE_CONTINUE; + + if (i->n_state_changes == 0) { + ret = gst_element_set_state (td->p, GST_STATE_PLAYING); + FAIL_IF (ret == GST_STATE_CHANGE_FAILURE); + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, td->p); + return G_SOURCE_REMOVE; + } + --i->n_state_changes; + + state = states[rand () % 4]; + ret = gst_element_set_state (td->p, state); + FAIL_IF (ret == GST_STATE_CHANGE_FAILURE); + + if (ret == GST_STATE_CHANGE_ASYNC) { + td->state_target = state; + d->async_state_change_completed = FALSE; + } + + return G_SOURCE_CONTINUE; +} + +static void +state_changes_stress_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + state_changes_stress_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + gst_object_ref (td->p); + g_timeout_add (50, (GSourceFunc) step_state_changes_stress, td); + } + d->async_state_change_completed = TRUE; +} + +static void +state_changes_stress_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = state_changes_stress_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static void +check_success_source_state_changes_stress (gpointer user_data) +{ + test_data *td = user_data; + state_changes_stress_input_data *i = td->id; + state_changes_stress_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); + FAIL_UNLESS_EQUALS_INT (i->n_state_changes, 0); +} + +GST_START_TEST (test_empty_state_changes_stress) +{ + state_changes_stress_input_data id = { 500 }; + state_changes_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, state_changes_stress_source, NULL, + check_success_source_state_changes_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_state_changes_stress) +{ + state_changes_stress_input_data id = { 500 }; + state_changes_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, state_changes_stress_source, NULL, + check_success_source_state_changes_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_state_changes_stress) +{ + state_changes_stress_input_data id = { 500 }; + state_changes_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, state_changes_stress_source, NULL, + check_success_source_state_changes_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_state_changes_stress) +{ + state_changes_stress_input_data id = { 500 }; + state_changes_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + state_changes_stress_source, NULL, + check_success_source_state_changes_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_state_changes_stress) +{ + state_changes_stress_input_data id = { 500 }; + state_changes_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, state_changes_stress_source, NULL, + check_success_source_state_changes_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_state_changes_stress) +{ + state_changes_stress_input_data id = { 500 }; + state_changes_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, state_changes_stress_source, NULL, + check_success_source_state_changes_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_state_changes_stress) +{ + state_changes_stress_input_data id = { 500 }; + state_changes_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + state_changes_stress_source, NULL, + check_success_source_state_changes_stress, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +/**** serialized query test ****/ + +typedef struct +{ + gboolean sent_query[2]; + gboolean got_query_reply[2]; + GstPad *pad[2]; +} serialized_query_master_data; + +typedef struct +{ + gboolean got_query; +} serialized_query_slave_data; + +static gboolean +send_drain (gpointer user_data) +{ + test_data *td = user_data; + serialized_query_master_data *d = td->md; + GstQuery *q; + gint idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + q = gst_query_new_drain (); + FAIL_UNLESS (gst_pad_query (d->pad[idx], q)); + d->got_query_reply[idx] = TRUE; + gst_query_unref (q); + gst_object_unref (d->pad[idx]); + } + + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, gst_object_ref (td->p)); + return G_SOURCE_REMOVE; +} + +static GstPadProbeReturn +serialized_query_probe_source (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + serialized_query_master_data *d = td->md; + GstClockTime ts; + gint idx; + + if (GST_IS_BUFFER (info->data)) { + ts = GST_BUFFER_TIMESTAMP (info->data); + idx = pad2idx (pad, td->two_streams); + if (!d->sent_query[idx] && GST_CLOCK_TIME_IS_VALID (ts) + && ts > STEP_AT * GST_MSECOND) { + g_atomic_int_set (&d->sent_query[idx], TRUE); + d->pad[idx] = gst_object_ref (pad); + if (!td->two_streams || g_atomic_int_get (&d->sent_query[idx ? 0 : 1])) + g_idle_add (send_drain, td); + } + } + return GST_PAD_PROBE_OK; +} + +static void +hook_serialized_query_probe_source (const GValue * v, gpointer user_data) +{ + hook_probe (v, serialized_query_probe_source, user_data); +} + +static void +serialized_query_source (GstElement * source, gpointer user_data) +{ + GstIterator *it; + GstStateChangeReturn ret; + + it = gst_bin_iterate_sinks (GST_BIN (source)); + while (gst_iterator_foreach (it, hook_serialized_query_probe_source, + user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC + || ret == GST_STATE_CHANGE_SUCCESS); +} + +static GstPadProbeReturn +serialized_query_probe (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + serialized_query_slave_data *d = td->sd; + + if (GST_IS_QUERY (info->data)) { + if (GST_QUERY_TYPE (info->data) == GST_QUERY_DRAIN) { + d->got_query = TRUE; + } + } + return GST_PAD_PROBE_OK; +} + +static void +hook_serialized_query_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, serialized_query_probe, user_data); +} + +static void +setup_sink_serialized_query (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_serialized_query_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_serialized_query (gpointer user_data) +{ + test_data *td = user_data; + serialized_query_master_data *d = td->md; + gint idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->sent_query[idx]); + FAIL_UNLESS (d->got_query_reply[idx]); + } +} + +static void +check_success_sink_serialized_query (gpointer user_data) +{ + test_data *td = user_data; + serialized_query_slave_data *d = td->sd; + + FAIL_UNLESS (d->got_query); +} + +GST_START_TEST (test_empty_serialized_query) +{ + serialized_query_master_data md = { 0 }; + serialized_query_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, serialized_query_source, + setup_sink_serialized_query, check_success_source_serialized_query, + check_success_sink_serialized_query, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_serialized_query) +{ + serialized_query_master_data md = { 0 }; + serialized_query_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, serialized_query_source, + setup_sink_serialized_query, check_success_source_serialized_query, + check_success_sink_serialized_query, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_serialized_query) +{ + serialized_query_master_data md = { 0 }; + serialized_query_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, serialized_query_source, + setup_sink_serialized_query, check_success_source_serialized_query, + check_success_sink_serialized_query, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_serialized_query) +{ + serialized_query_master_data md = { 0 }; + serialized_query_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + serialized_query_source, setup_sink_serialized_query, + check_success_source_serialized_query, + check_success_sink_serialized_query, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_serialized_query) +{ + serialized_query_master_data md = { 0 }; + serialized_query_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, serialized_query_source, + setup_sink_serialized_query, check_success_source_serialized_query, + check_success_sink_serialized_query, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_serialized_query) +{ + serialized_query_master_data md = { 0 }; + serialized_query_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, serialized_query_source, + setup_sink_serialized_query, check_success_source_serialized_query, + check_success_sink_serialized_query, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_serialized_query) +{ + serialized_query_master_data md = { 0 }; + serialized_query_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + serialized_query_source, setup_sink_serialized_query, + check_success_source_serialized_query, + check_success_sink_serialized_query, NULL, &md, &sd); +} + +GST_END_TEST; + +/**** non serialized event test ****/ + +typedef struct +{ + gboolean sent_event[2]; +} non_serialized_event_master_data; + +typedef struct +{ + gboolean got_event; +} non_serialized_event_slave_data; + +static GstPadProbeReturn +non_serialized_event_probe_source (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + non_serialized_event_master_data *d = td->md; + GstClockTime ts; + GstEvent *e; + gint idx; + + if (GST_IS_BUFFER (info->data)) { + ts = GST_BUFFER_TIMESTAMP (info->data); + idx = pad2idx (pad, td->two_streams); + if (!g_atomic_int_get (&d->sent_event[idx]) + && GST_CLOCK_TIME_IS_VALID (ts) && ts > STEP_AT * GST_MSECOND) { + e = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_OOB, + gst_structure_new ("name", "field", G_TYPE_INT, 42, NULL)); + FAIL_UNLESS (e); + FAIL_UNLESS (gst_pad_send_event (pad, e)); + + if (!td->two_streams || g_atomic_int_get (&d->sent_event[idx ? 0 : 1])) { + g_timeout_add (STEP_AT, (GSourceFunc) stop_pipeline, + gst_object_ref (td->p)); + } + g_atomic_int_set (&d->sent_event[idx], TRUE); + } + } + return GST_PAD_PROBE_OK; +} + +static void +hook_non_serialized_event_probe_source (const GValue * v, gpointer user_data) +{ + hook_probe (v, non_serialized_event_probe_source, user_data); +} + +static void +non_serialized_event_source (GstElement * source, gpointer user_data) +{ + GstIterator *it; + GstStateChangeReturn ret; + + it = gst_bin_iterate_sinks (GST_BIN (source)); + while (gst_iterator_foreach (it, hook_non_serialized_event_probe_source, + user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC + || ret == GST_STATE_CHANGE_SUCCESS); +} + +static GstPadProbeReturn +non_serialized_event_probe (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + non_serialized_event_slave_data *d = td->sd; + const GstStructure *s; + gint val; + + if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_CUSTOM_DOWNSTREAM_OOB) { + s = gst_event_get_structure (info->data); + FAIL_UNLESS (!strcmp (gst_structure_get_name (s), "name")); + FAIL_UNLESS (gst_structure_get_int (s, "field", &val)); + FAIL_UNLESS (val == 42); + d->got_event = TRUE; + } + } + return GST_PAD_PROBE_OK; +} + +static void +hook_non_serialized_event_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, non_serialized_event_probe, user_data); +} + +static void +setup_sink_non_serialized_event (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_non_serialized_event_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_non_serialized_event (gpointer user_data) +{ + test_data *td = user_data; + non_serialized_event_master_data *d = td->md; + gint idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->sent_event[idx]); + } +} + +static void +check_success_sink_non_serialized_event (gpointer user_data) +{ + test_data *td = user_data; + non_serialized_event_slave_data *d = td->sd; + + FAIL_UNLESS (d->got_event); +} + +GST_START_TEST (test_empty_non_serialized_event) +{ + non_serialized_event_master_data md = { 0 }; + non_serialized_event_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, non_serialized_event_source, + setup_sink_non_serialized_event, + check_success_source_non_serialized_event, + check_success_sink_non_serialized_event, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_non_serialized_event) +{ + non_serialized_event_master_data md = { 0 }; + non_serialized_event_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, non_serialized_event_source, + setup_sink_non_serialized_event, + check_success_source_non_serialized_event, + check_success_sink_non_serialized_event, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_non_serialized_event) +{ + non_serialized_event_master_data md = { 0 }; + non_serialized_event_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, non_serialized_event_source, + setup_sink_non_serialized_event, + check_success_source_non_serialized_event, + check_success_sink_non_serialized_event, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_non_serialized_event) +{ + non_serialized_event_master_data md = { 0 }; + non_serialized_event_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, + non_serialized_event_source, setup_sink_non_serialized_event, + check_success_source_non_serialized_event, + check_success_sink_non_serialized_event, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_non_serialized_event) +{ + non_serialized_event_master_data md = { 0 }; + non_serialized_event_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, non_serialized_event_source, + setup_sink_non_serialized_event, + check_success_source_non_serialized_event, + check_success_sink_non_serialized_event, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_non_serialized_event) +{ + non_serialized_event_master_data md = { 0 }; + non_serialized_event_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, non_serialized_event_source, + setup_sink_non_serialized_event, + check_success_source_non_serialized_event, + check_success_sink_non_serialized_event, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_non_serialized_event) +{ + non_serialized_event_master_data md = { 0 }; + non_serialized_event_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + non_serialized_event_source, setup_sink_non_serialized_event, + check_success_source_non_serialized_event, + check_success_sink_non_serialized_event, NULL, &md, &sd); +} + +GST_END_TEST; + +/**** meta test ****/ + +enum +{ + TEST_META_PROTECTION = 0, + N_TEST_META +}; + +typedef struct +{ + gboolean meta_sent[N_TEST_META]; +} meta_master_data; + +typedef struct +{ + gboolean meta_received[N_TEST_META]; +} meta_slave_data; + +static GstPadProbeReturn +meta_probe_source (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + meta_master_data *d = td->md; + GstBuffer *buffer; + GstProtectionMeta *meta; + + if (GST_IS_BUFFER (info->data)) { + buffer = GST_BUFFER (info->data); + meta = + gst_buffer_add_protection_meta (buffer, gst_structure_new ("name", + "somefield", G_TYPE_INT, 42, NULL)); + FAIL_UNLESS (meta); + d->meta_sent[TEST_META_PROTECTION] = TRUE; + } + return GST_PAD_PROBE_OK; +} + +static void +hook_meta_probe_source (const GValue * v, gpointer user_data) +{ + hook_probe (v, meta_probe_source, user_data); +} + +static void +meta_source (GstElement * source, gpointer user_data) +{ + GstIterator *it; + GstStateChangeReturn ret; + + it = gst_bin_iterate_sinks (GST_BIN (source)); + while (gst_iterator_foreach (it, hook_meta_probe_source, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC + || ret == GST_STATE_CHANGE_SUCCESS); + + g_timeout_add (STOP_AT, (GSourceFunc) stop_pipeline, gst_object_ref (source)); +} + +static gboolean +scan_meta (GstBuffer * buffer, GstMeta ** meta, gpointer user_data) +{ + test_data *td = user_data; + meta_slave_data *d = td->sd; + int val; + GstStructure *s; + GstProtectionMeta *pmeta; + + if ((*meta)->info->api == GST_PROTECTION_META_API_TYPE) { + pmeta = (GstProtectionMeta *) * meta; + FAIL_UNLESS (GST_IS_STRUCTURE (pmeta->info)); + s = GST_STRUCTURE (pmeta->info); + FAIL_UNLESS (!strcmp (gst_structure_get_name (s), "name")); + FAIL_UNLESS (gst_structure_get_int (s, "somefield", &val)); + FAIL_UNLESS (val == 42); + d->meta_received[TEST_META_PROTECTION] = TRUE; + } + return TRUE; +} + +static GstPadProbeReturn +meta_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + if (GST_IS_BUFFER (info->data)) { + gst_buffer_foreach_meta (info->data, scan_meta, user_data); + } + return GST_PAD_PROBE_OK; +} + +static void +hook_meta_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, meta_probe, user_data); +} + +static void +setup_sink_meta (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_meta_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_meta (gpointer user_data) +{ + test_data *td = user_data; + meta_master_data *d = td->md; + size_t n; + + for (n = 0; n < N_TEST_META; ++n) + FAIL_UNLESS (d->meta_sent[n]); +} + +static void +check_success_sink_meta (gpointer user_data) +{ + test_data *td = user_data; + meta_slave_data *d = td->sd; + size_t n; + + for (n = 0; n < N_TEST_META; ++n) + FAIL_UNLESS (d->meta_received[n]); +} + +GST_START_TEST (test_empty_meta) +{ + meta_master_data md = { 0 }; + meta_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE, meta_source, setup_sink_meta, + check_success_source_meta, check_success_sink_meta, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_meta) +{ + meta_master_data md = { 0 }; + meta_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, meta_source, setup_sink_meta, + check_success_source_meta, check_success_sink_meta, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_meta) +{ + meta_master_data md = { 0 }; + meta_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE, meta_source, setup_sink_meta, + check_success_source_meta, check_success_sink_meta, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_meta) +{ + meta_master_data md = { 0 }; + meta_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_SPLIT_SINKS, meta_source, + setup_sink_meta, check_success_source_meta, check_success_sink_meta, + NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_meta) +{ + meta_master_data md = { 0 }; + meta_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE, meta_source, setup_sink_meta, + check_success_source_meta, check_success_sink_meta, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_meta) +{ + meta_master_data md = { 0 }; + meta_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, meta_source, setup_sink_meta, + check_success_source_meta, check_success_sink_meta, NULL, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_meta) +{ + meta_master_data md = { 0 }; + meta_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + meta_source, setup_sink_meta, check_success_source_meta, + check_success_sink_meta, NULL, &md, &sd); +} + +GST_END_TEST; + +/**** source change test ****/ + +typedef struct +{ + void (*switcher) (GstElement *, char *name); +} source_change_input_data; + +typedef struct +{ + gboolean source_change_scheduled; + gboolean source_changed; +} source_change_master_data; + +typedef struct +{ + gboolean got_caps[2][2]; + gboolean got_buffer[2][2]; + GstCaps *caps[2]; +} source_change_slave_data; + +static gboolean +stop_source (gpointer user_data) +{ + GstElement *source = user_data; + + FAIL_UNLESS (gst_element_set_state (source, + GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS); + gst_object_unref (source); + return FALSE; +} + +static gboolean +remove_source (gpointer user_data) +{ + GstElement *source = user_data; + + FAIL_UNLESS (gst_element_set_state (source, + GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS); + gst_bin_remove (GST_BIN (GST_ELEMENT_PARENT (source)), source); + return FALSE; +} + +static void +switch_to_aiff (GstElement * pipeline, char *name) +{ + GstElement *sbin, *filesrc, *ipcpipelinesink; + GError *e = NULL; + + sbin = + gst_parse_bin_from_description ("pushfilesrc name=filesrc ! aiffparse", + TRUE, &e); + FAIL_IF (e || !sbin); + gst_element_set_name (sbin, name); + filesrc = gst_bin_get_by_name (GST_BIN (sbin), "filesrc"); + FAIL_UNLESS (filesrc); + g_object_set (filesrc, "location", "../../tests/files/s16be-id3v2.aiff", + NULL); + gst_object_unref (filesrc); + gst_bin_add (GST_BIN (pipeline), sbin); + ipcpipelinesink = gst_bin_get_by_name (GST_BIN (pipeline), "ipcpipelinesink"); + FAIL_UNLESS (ipcpipelinesink); + FAIL_UNLESS (gst_element_link (sbin, ipcpipelinesink)); + gst_object_unref (ipcpipelinesink); + gst_element_sync_state_with_parent (sbin); + g_free (name); +} + +static void +switch_av (GstElement * pipeline, char *name, gboolean live, gboolean Long) +{ + GstElement *src, *ipcpipelinesink; + gint L = Long ? 10 : 1; + + if (g_str_has_prefix (name, "videotestsrc")) { + /* replace video source with audio source */ + src = gst_element_factory_make ("audiotestsrc", NULL); + FAIL_UNLESS (src); + g_object_set (src, "is-live", live, "num-buffers", live ? 27 * L : -1, + NULL); + gst_bin_add (GST_BIN (pipeline), src); + ipcpipelinesink = + gst_bin_get_by_name (GST_BIN (pipeline), "vipcpipelinesink"); + FAIL_UNLESS (ipcpipelinesink); + FAIL_UNLESS (gst_element_link (src, ipcpipelinesink)); + gst_object_unref (ipcpipelinesink); + gst_element_sync_state_with_parent (src); + } + + if (g_str_has_prefix (name, "audiotestsrc")) { + /* replace audio source with video source */ + src = gst_element_factory_make ("videotestsrc", NULL); + FAIL_UNLESS (src); + g_object_set (src, "is-live", live, "num-buffers", live ? 19 * L : -1, + NULL); + gst_bin_add (GST_BIN (pipeline), src); + ipcpipelinesink = + gst_bin_get_by_name (GST_BIN (pipeline), "aipcpipelinesink"); + FAIL_UNLESS (ipcpipelinesink); + FAIL_UNLESS (gst_element_link (src, ipcpipelinesink)); + gst_object_unref (ipcpipelinesink); + gst_element_sync_state_with_parent (src); + } + + g_free (name); +} + +static void +switch_live_av (GstElement * pipeline, char *name) +{ + switch_av (pipeline, name, TRUE, FALSE); +} + +static GstPadProbeReturn +change_source_blocked (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + const source_change_input_data *i = td->id; + source_change_master_data *d = td->md; + GstElement *source; + GstPad *peer; + + peer = gst_pad_get_peer (pad); + FAIL_UNLESS (peer); + FAIL_UNLESS (gst_pad_unlink (pad, peer)); + gst_object_unref (peer); + + source = GST_ELEMENT (gst_element_get_parent (pad)); + FAIL_UNLESS (source); + g_object_set_qdata (G_OBJECT (source), to_be_removed_quark (), + GINT_TO_POINTER (1)); + + gst_bin_remove (GST_BIN (GST_ELEMENT_PARENT (source)), source); + (*i->switcher) (td->p, gst_element_get_name (source)); + + g_idle_add (stop_source, source); + + d->source_changed = TRUE; + + gst_object_unref (td->p); + return GST_PAD_PROBE_REMOVE; +} + +static gboolean +change_source (gpointer user_data) +{ + test_data *td = user_data; + GstElement *source; + GstPad *pad; + static const char *const names[] = + { "source", "audiotestsrc", "videotestsrc" }; + gboolean found = FALSE; + size_t n; + + for (n = 0; n < G_N_ELEMENTS (names); ++n) { + source = gst_bin_get_by_name (GST_BIN (td->p), names[n]); + if (source) { + found = TRUE; + pad = gst_element_get_static_pad (source, "src"); + FAIL_UNLESS (pad); + gst_object_ref (td->p); + gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_IDLE, change_source_blocked, + user_data, NULL); + gst_object_unref (pad); + gst_object_unref (source); + } + } + FAIL_UNLESS (found); + + gst_object_unref (td->p); + return G_SOURCE_REMOVE; +} + +static void +source_change_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + source_change_master_data *d = td->md; + + if (!d->source_change_scheduled) { + d->source_change_scheduled = TRUE; + gst_object_ref (td->p); + g_timeout_add (STEP_AT, change_source, td); + } +} + +static void +source_change_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = source_change_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC + || ret == GST_STATE_CHANGE_SUCCESS); +} + +static int +scppad2idx (GstPad * pad, gboolean two_streams, GstCaps * newcaps) +{ + static GQuark scpidx = 0; + gpointer p; + int idx; + GstCaps *caps; + + if (!scpidx) + scpidx = g_quark_from_static_string ("scpidx"); + + if (!two_streams) + return 0; + + p = g_object_get_qdata (G_OBJECT (pad), scpidx); + if (p) + return GPOINTER_TO_INT (p) - 1; + + caps = gst_pad_get_current_caps (pad); + if (!caps) + caps = gst_pad_get_pad_template_caps (pad); + if ((!caps || gst_caps_is_any (caps)) && newcaps) + caps = gst_caps_ref (newcaps); + FAIL_UNLESS (caps); + idx = caps2idx (caps, two_streams); + gst_caps_unref (caps); + g_object_set_qdata (G_OBJECT (pad), scpidx, GINT_TO_POINTER (idx + 1)); + return idx; +} + +static GstPadProbeReturn +source_change_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + source_change_slave_data *d = td->sd; + GstCaps *caps; + int idx; + + if (GST_IS_BUFFER (info->data)) { + idx = scppad2idx (pad, td->two_streams, NULL); + if (d->got_caps[idx][1]) + d->got_buffer[idx][1] = TRUE; + else if (d->got_caps[idx][0]) + d->got_buffer[idx][0] = TRUE; + } else if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_CAPS) { + gst_event_parse_caps (info->data, &caps); + idx = scppad2idx (pad, td->two_streams, caps); + if (!d->got_caps[idx][0]) { + FAIL_IF (d->caps[idx]); + d->got_caps[idx][0] = TRUE; + d->caps[idx] = gst_caps_ref (caps); + } else { + FAIL_UNLESS (d->caps); + if (gst_caps_is_equal (caps, d->caps[idx])) { + FAIL (); + } else { + gst_caps_replace (&d->caps[idx], NULL); + d->got_caps[idx][1] = TRUE; + } + } + } + } + return GST_PAD_PROBE_OK; +} + +static void +hook_source_change_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, source_change_probe, user_data); +} + +static void +setup_sink_source_change (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_source_change_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); +} + +static void +check_success_source_source_change (gpointer user_data) +{ + test_data *td = user_data; + source_change_master_data *d = td->md; + + FAIL_UNLESS (d->source_change_scheduled); + FAIL_UNLESS (d->source_changed); +} + +static void +check_success_sink_source_change (gpointer user_data) +{ + test_data *td = user_data; + source_change_slave_data *d = td->sd; + int idx; + + for (idx = 0; idx < (td->two_streams ? 2 : 1); idx++) { + FAIL_UNLESS (d->got_caps[idx][0]); + FAIL_UNLESS (d->got_buffer[idx][0]); + FAIL_UNLESS (d->got_caps[idx][1]); + FAIL_UNLESS (d->got_buffer[idx][1]); + } +} + +GST_START_TEST (test_non_live_source_change) +{ + source_change_input_data id = { switch_to_aiff }; + source_change_master_data md = { 0 }; + source_change_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE, source_change_source, + setup_sink_source_change, check_success_source_source_change, + check_success_sink_source_change, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_source_change) +{ + source_change_input_data id = { switch_live_av }; + source_change_master_data md = { 0 }; + source_change_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, source_change_source, + setup_sink_source_change, check_success_source_source_change, + check_success_sink_source_change, &id, &md, &sd); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_source_change) +{ + source_change_input_data id = { switch_live_av }; + source_change_master_data md = { 0 }; + source_change_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + source_change_source, setup_sink_source_change, + check_success_source_source_change, check_success_sink_source_change, + &id, &md, &sd); +} + +GST_END_TEST; + +/**** dynamic pipeline change stress test ****/ + +typedef struct +{ + guint n_switches_0; + void (*switcher0) (test_data *); + guint n_switches_1; + void (*switcher1) (test_data *); +} dynamic_pipeline_change_stress_input_data; + +typedef struct +{ + GMutex mutex; + GCond cond; + guint n_blocks_left; + guint n_blocks_done; + gboolean adding_probes; + gboolean dynamic_pipeline_change_stress_scheduled; +} dynamic_pipeline_change_stress_master_data; + +static gboolean dynamic_pipeline_change_stress_step (gpointer user_data); + +static GstPadProbeReturn +dynamic_pipeline_change_stress_source_blocked_switch_av (GstPad * pad, + GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + dynamic_pipeline_change_stress_master_data *d = td->md; + GstElement *source; + GstPad *peer; + + /* An idle pad probe could be called directly from the gst_pad_add_probe call + if the pad happens to be idle right now. This would deadlock us though, as + we need all pads to be blocked at the same time, so we need the iteration + over all pads to be done before the pad probes execute. So we keep track of + whether we're iterating to add the probes, and pass if so. */ + if (d->adding_probes) { + return GST_PAD_PROBE_PASS; + } + + peer = gst_pad_get_peer (pad); + FAIL_UNLESS (peer); + FAIL_UNLESS (gst_pad_unlink (pad, peer)); + gst_object_unref (peer); + + source = GST_ELEMENT (gst_element_get_parent (pad)); + FAIL_UNLESS (source); + g_object_set_qdata (G_OBJECT (source), to_be_removed_quark (), + GINT_TO_POINTER (1)); + + /* we want all pads to be blocked before we proceed */ + g_mutex_lock (&d->mutex); + d->n_blocks_left--; + while (d->n_blocks_left > 0) + g_cond_wait (&d->cond, &d->mutex); + g_mutex_unlock (&d->mutex); + g_cond_broadcast (&d->cond); + + g_mutex_lock (&d->mutex); + switch_av (td->p, gst_element_get_name (source), + ! !(td->features & TEST_FEATURE_LIVE), TRUE); + g_mutex_unlock (&d->mutex); + + g_idle_add_full (G_PRIORITY_HIGH, remove_source, source, g_object_unref); + + if (g_atomic_int_dec_and_test (&d->n_blocks_done)) + g_timeout_add (STEP_AT, dynamic_pipeline_change_stress_step, td); + + return GST_PAD_PROBE_REMOVE; +} + +static void +change_audio_channel (GstElement * pipeline, char *name, + const char *ipcpipelinesink_name, gboolean live) +{ + GstElement *src, *ipcpipelinesink; + + /* replace audio source with video source */ + src = gst_element_factory_make ("audiotestsrc", NULL); + FAIL_UNLESS (src); + g_object_set (src, "is-live", live, "num-buffers", live ? 190 : -1, NULL); + + gst_bin_add (GST_BIN (pipeline), src); + ipcpipelinesink = + gst_bin_get_by_name (GST_BIN (pipeline), ipcpipelinesink_name); + FAIL_UNLESS (ipcpipelinesink); + FAIL_UNLESS (gst_element_link (src, ipcpipelinesink)); + gst_object_unref (ipcpipelinesink); + gst_element_sync_state_with_parent (src); + + g_free (name); +} + +static GstPadProbeReturn +dynamic_pipeline_change_stress_source_blocked_change_audio_channel (GstPad * + pad, GstPadProbeInfo * info, gpointer user_data) +{ + test_data *td = user_data; + dynamic_pipeline_change_stress_master_data *d = td->md; + GstElement *source; + GstPad *peer; + const char *ipcpipelinesink_name; + + /* An idle pad probe could be called directly from the gst_pad_add_probe call + if the pad happens to be idle right now. This would deadlock us though, as + we need all pads to be blocked at the same time, so we need the iteration + over all pads to be done before the pad probes execute. So we keep track of + whether we're iterating to add the probes, and pass if so. */ + if (d->adding_probes) { + return GST_PAD_PROBE_PASS; + } + + peer = gst_pad_get_peer (pad); + FAIL_UNLESS (peer); + ipcpipelinesink_name = GST_ELEMENT_NAME (GST_PAD_PARENT (peer)); + FAIL_UNLESS (gst_pad_unlink (pad, peer)); + gst_object_unref (peer); + + source = GST_ELEMENT (gst_element_get_parent (pad)); + FAIL_UNLESS (source); + g_object_set_qdata (G_OBJECT (source), to_be_removed_quark (), + GINT_TO_POINTER (1)); + + /* we want all pads to be blocked before we proceed */ + g_mutex_lock (&d->mutex); + d->n_blocks_left--; + while (d->n_blocks_left > 0) + g_cond_wait (&d->cond, &d->mutex); + g_cond_broadcast (&d->cond); + g_mutex_unlock (&d->mutex); + + g_mutex_lock (&d->mutex); + change_audio_channel (td->p, gst_element_get_name (source), + ipcpipelinesink_name, ! !(td->features & TEST_FEATURE_LIVE)); + g_mutex_unlock (&d->mutex); + + g_idle_add_full (G_PRIORITY_HIGH, remove_source, source, g_object_unref); + + if (g_atomic_int_dec_and_test (&d->n_blocks_done)) + g_timeout_add (STEP_AT, dynamic_pipeline_change_stress_step, td); + + return GST_PAD_PROBE_REMOVE; +} + +typedef struct +{ + const char *const *names; + size_t n_names; + GstPadProbeReturn (*f) (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data); + test_data *td; +} block_if_named_data; + +static void +block_if_named (const GValue * v, gpointer user_data) +{ + block_if_named_data *bind = user_data; + GstElement *e; + GstPad *pad; + size_t n; + + e = g_value_get_object (v); + FAIL_UNLESS (e); + for (n = 0; n < bind->n_names; ++n) { + if (g_str_has_prefix (GST_ELEMENT_NAME (e), bind->names[n])) { + pad = gst_element_get_static_pad (e, "src"); + FAIL_UNLESS (pad); + + if (!g_object_get_qdata (G_OBJECT (e), to_be_removed_quark ())) + gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_IDLE, bind->f, bind->td, + NULL); + gst_object_unref (pad); + } + } +} + +static void +count_audio_sources (const GValue * v, gpointer user_data) +{ + GstElement *e; + + e = g_value_get_object (v); + FAIL_UNLESS (e); + + // we don't want to count the sources that are in the process + // of being removed asynchronously + if (g_object_get_qdata (G_OBJECT (e), to_be_removed_quark ())) + return; + + if (g_str_has_prefix (GST_ELEMENT_NAME (e), "audiotestsrc")) + ++ * (guint *) user_data; +} + +static void +dynamic_pipeline_change_stress_swap_source (test_data * td) +{ + dynamic_pipeline_change_stress_master_data *d = td->md; + static const char *const names[] = + { "source", "audiotestsrc", "videotestsrc" }; + block_if_named_data bind = { names, sizeof (names) / sizeof (names[0]), + dynamic_pipeline_change_stress_source_blocked_switch_av, td + }; + GstIterator *it; + + /* we have two sources, we need to wait for both */ + d->n_blocks_left = d->n_blocks_done = 2; + + it = gst_bin_iterate_sources (GST_BIN (td->p)); + d->adding_probes = TRUE; + while (gst_iterator_foreach (it, block_if_named, &bind)) { + GST_INFO_OBJECT (td->p, "Resync"); + gst_iterator_resync (it); + } + d->adding_probes = FALSE; + gst_iterator_free (it); +} + +static void +dynamic_pipeline_change_stress_change_audio_channel (test_data * td) +{ + dynamic_pipeline_change_stress_master_data *d = td->md; + static const char *const names[] = { "audiotestsrc" }; + block_if_named_data bind = { names, sizeof (names) / sizeof (names[0]), + dynamic_pipeline_change_stress_source_blocked_change_audio_channel, td + }; + GstIterator *it; + guint audio_sources; + + /* we have either zero or one audio source */ + it = gst_bin_iterate_sources (GST_BIN (td->p)); + audio_sources = 0; + while (gst_iterator_foreach (it, count_audio_sources, &audio_sources)) { + GST_INFO_OBJECT (td->p, "Resync"); + gst_iterator_resync (it); + } + gst_iterator_free (it); + d->n_blocks_left = d->n_blocks_done = audio_sources; + + it = gst_bin_iterate_sources (GST_BIN (td->p)); + d->adding_probes = TRUE; + while (gst_iterator_foreach (it, block_if_named, &bind)) { + GST_INFO_OBJECT (td->p, "Resync"); + gst_iterator_resync (it); + } + d->adding_probes = FALSE; + gst_iterator_free (it); +} + +static gboolean +dynamic_pipeline_change_stress_step (gpointer user_data) +{ + test_data *td = user_data; + dynamic_pipeline_change_stress_input_data *i = td->id; + guint available, idx; + + /* pick a random action among the ones we have left */ + available = i->n_switches_0 + i->n_switches_1; + if (available == 0) { + GST_INFO_OBJECT (td->p, "Destroying pipeline"); + FAIL_UNLESS (gst_element_set_state (td->p, + GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE); + g_timeout_add (STEP_AT, stop_pipeline, td->p); + return G_SOURCE_REMOVE; + } + + idx = rand () % available; + if (idx < i->n_switches_0) { + (*i->switcher0) (td); + --i->n_switches_0; + return G_SOURCE_REMOVE; + } + idx -= i->n_switches_0; + + if (idx < i->n_switches_1) { + (*i->switcher1) (td); + --i->n_switches_1; + return G_SOURCE_REMOVE; + } + idx -= i->n_switches_1; + + return G_SOURCE_REMOVE; +} + +static void +dynamic_pipeline_change_stress_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + dynamic_pipeline_change_stress_master_data *d = td->md; + + if (!d->dynamic_pipeline_change_stress_scheduled) { + d->dynamic_pipeline_change_stress_scheduled = TRUE; + gst_object_ref (td->p); + g_timeout_add (STEP_AT, dynamic_pipeline_change_stress_step, td); + } +} + +static void +dynamic_pipeline_change_stress (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + dynamic_pipeline_change_stress_master_data *d = td->md; + GstStateChangeReturn ret; + + g_mutex_init (&d->mutex); + g_cond_init (&d->cond); + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = dynamic_pipeline_change_stress_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC + || ret == GST_STATE_CHANGE_SUCCESS); +} + +static void +check_success_source_dynamic_pipeline_change_stress (gpointer user_data) +{ + test_data *td = user_data; + dynamic_pipeline_change_stress_input_data *i = td->id; + dynamic_pipeline_change_stress_master_data *d = td->md; + + FAIL_UNLESS (d->dynamic_pipeline_change_stress_scheduled); + FAIL_UNLESS_EQUALS_INT (i->n_switches_0, 0); + FAIL_UNLESS_EQUALS_INT (i->n_switches_1, 0); + + g_cond_clear (&d->cond); + g_mutex_clear (&d->mutex); +} + +GST_START_TEST (test_non_live_av_dynamic_pipeline_change_stress) +{ + dynamic_pipeline_change_stress_input_data id = { 100, + dynamic_pipeline_change_stress_swap_source, 100, + dynamic_pipeline_change_stress_change_audio_channel + }; + dynamic_pipeline_change_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_HAS_VIDEO, + dynamic_pipeline_change_stress, NULL, + check_success_source_dynamic_pipeline_change_stress, NULL, &id, &md, + NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_non_live_av_2_dynamic_pipeline_change_stress) +{ + dynamic_pipeline_change_stress_input_data id = { 100, + dynamic_pipeline_change_stress_swap_source, 100, + dynamic_pipeline_change_stress_change_audio_channel + }; + dynamic_pipeline_change_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_HAS_VIDEO | + TEST_FEATURE_SPLIT_SINKS, dynamic_pipeline_change_stress, NULL, + check_success_source_dynamic_pipeline_change_stress, NULL, &id, &md, + NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_dynamic_pipeline_change_stress) +{ + dynamic_pipeline_change_stress_input_data id = { 100, + dynamic_pipeline_change_stress_swap_source, 100, + dynamic_pipeline_change_stress_change_audio_channel + }; + dynamic_pipeline_change_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE, dynamic_pipeline_change_stress, NULL, + check_success_source_dynamic_pipeline_change_stress, NULL, &id, &md, + NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_dynamic_pipeline_change_stress) +{ + dynamic_pipeline_change_stress_input_data id = { 100, + dynamic_pipeline_change_stress_swap_source, 100, + dynamic_pipeline_change_stress_change_audio_channel + }; + dynamic_pipeline_change_stress_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_SPLIT_SINKS, + dynamic_pipeline_change_stress, NULL, + check_success_source_dynamic_pipeline_change_stress, NULL, &id, &md, + NULL); +} + +GST_END_TEST; + +/**** error from slave test ****/ + +typedef struct +{ + gboolean crash; +} error_from_slave_input_data; + +typedef struct +{ + gboolean second_pass; + gboolean got_state_changed_to_playing_on_first_pass; + gboolean got_error_on_first_pass; + gboolean got_state_changed_to_playing_on_second_pass; + gboolean got_error_on_second_pass; +} error_from_slave_master_data; + +static gboolean +bump_through_NULL (gpointer user_data) +{ + test_data *td = user_data; + error_from_slave_input_data *i = td->id; + error_from_slave_master_data *d = td->md; + GstStateChangeReturn ret; + GstElement *sink; + + ret = gst_element_set_state (td->p, GST_STATE_NULL); + if (!i->crash) { + FAIL_UNLESS (ret == GST_STATE_CHANGE_SUCCESS); + } + FAIL_UNLESS (gst_element_get_state (td->p, NULL, NULL, + GST_CLOCK_TIME_NONE) == GST_STATE_CHANGE_SUCCESS); + + d->second_pass = TRUE; + + if (i->crash) { + recreate_crashed_slave_process (); + /* give the process time to be created in the other process */ + g_usleep (500 * 1000); + + /* reconnect to to slave process */ + sink = gst_bin_get_by_name (GST_BIN (td->p), "ipcpipelinesink"); + FAIL_UNLESS (sink); + g_object_set (sink, "fdin", pipesba[0], "fdout", pipesfa[1], NULL); + gst_object_unref (sink); + } + + ret = gst_element_set_state (td->p, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_SUCCESS + || ret == GST_STATE_CHANGE_ASYNC); + + g_timeout_add (STOP_AT, (GSourceFunc) stop_pipeline, td->p); + return G_SOURCE_REMOVE; +} + +static void +disconnect (const GValue * v, gpointer user_data) +{ + GstElement *e; + + e = g_value_get_object (v); + FAIL_UNLESS (e); + g_signal_emit_by_name (G_OBJECT (e), "disconnect", NULL); +} + +static gboolean +error_from_slave_source_bus_msg (GstBus * bus, GstMessage * message, + gpointer user_data) +{ + test_data *td = user_data; + error_from_slave_input_data *i = td->id; + error_from_slave_master_data *d = td->md; + + if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) { + if (!d->second_pass) { + if (!d->got_error_on_first_pass) { + GstIterator *it; + + d->got_error_on_first_pass = TRUE; + + if (i->crash) { + it = gst_bin_iterate_sinks (GST_BIN (td->p)); + while (gst_iterator_foreach (it, disconnect, NULL)) + gst_iterator_resync (it); + gst_iterator_free (it); + } + + gst_object_ref (td->p); + g_timeout_add (STEP_AT, bump_through_NULL, td); + } + + /* don't pass the expected error */ + return TRUE; + } + } else if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_EOS) { + if (!d->second_pass) { + /* We'll get an expected EOS as the source reacts to the error */ + return TRUE; + } + } + return master_bus_msg (bus, message, user_data); +} + +static void +error_from_slave_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + error_from_slave_master_data *d = td->md; + + if (d->second_pass) + d->got_state_changed_to_playing_on_second_pass = TRUE; + else + d->got_state_changed_to_playing_on_first_pass = TRUE; +} + +static gboolean +error_from_slave_position_getter (GstElement * element) +{ + gint64 pos; + + /* we do not care about the result */ + gst_element_query_position (element, GST_FORMAT_TIME, &pos); + + return TRUE; +} + +static void +error_from_slave_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + /* we're on the source, there's already the basic master_bus_msg watch, + and gst doesn't want more than one watch, so we remove the watch and + call it directly when done in the new watch */ + gst_bus_remove_watch (GST_ELEMENT_BUS (source)); + gst_bus_add_watch (GST_ELEMENT_BUS (source), error_from_slave_source_bus_msg, + user_data); + g_timeout_add (STEP_AT, (GSourceFunc) error_from_slave_position_getter, + source); + + td->state_changed_cb = error_from_slave_on_state_changed; + td->state_target = GST_STATE_PLAYING; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC); +} + +static gboolean +error_from_slave_sink_bus_msg (GstBus * bus, GstMessage * message, + gpointer user_data) +{ + test_data *td = user_data; + error_from_slave_input_data *i = td->id; + + switch (GST_MESSAGE_TYPE (message)) { + case GST_MESSAGE_ERROR: + if (!strcmp (GST_ELEMENT_NAME (GST_MESSAGE_SRC (message)), + "error-element")) + g_object_set (GST_MESSAGE_SRC (message), "error-after", -1, NULL); + break; + case GST_MESSAGE_ASYNC_DONE: + if (GST_IS_PIPELINE (GST_MESSAGE_SRC (message))) { + /* We have two identical processes, and only one must crash. They can + be distinguished by recovery_pid, however. */ + if (i->crash && recovery_pid) + g_timeout_add (CRASH_AT, (GSourceFunc) crash, NULL); + } + break; + default: + break; + } + return TRUE; +} + +static void +setup_sink_error_from_slave (GstElement * sink, gpointer user_data) +{ + gst_bus_add_watch (GST_ELEMENT_BUS (sink), error_from_slave_sink_bus_msg, + user_data); +} + +static void +check_success_source_error_from_slave (gpointer user_data) +{ + test_data *td = user_data; + error_from_slave_master_data *d = td->md; + + FAIL_UNLESS (d->second_pass); + FAIL_UNLESS (d->got_state_changed_to_playing_on_first_pass); + FAIL_UNLESS (d->got_state_changed_to_playing_on_second_pass); + FAIL_UNLESS (d->got_error_on_first_pass); + FAIL_IF (d->got_error_on_second_pass); +} + +GST_START_TEST (test_empty_error_from_slave) +{ + error_from_slave_input_data id = { FALSE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_TEST_SOURCE | TEST_FEATURE_ERROR_SINK, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_error_from_slave) +{ + error_from_slave_input_data id = { FALSE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE | TEST_FEATURE_ERROR_SINK, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_error_from_slave) +{ + error_from_slave_input_data id = { FALSE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_ERROR_SINK, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_mpegts_2_error_from_slave) +{ + error_from_slave_input_data id = { FALSE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_MPEGTS_SOURCE | TEST_FEATURE_ERROR_SINK | + TEST_FEATURE_SPLIT_SINKS, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_a_error_from_slave) +{ + error_from_slave_input_data id = { FALSE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_A_SOURCE | TEST_FEATURE_ERROR_SINK, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_error_from_slave) +{ + error_from_slave_input_data id = { FALSE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_ERROR_SINK, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_live_av_2_error_from_slave) +{ + error_from_slave_input_data id = { FALSE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_LIVE_AV_SOURCE | TEST_FEATURE_ERROR_SINK | + TEST_FEATURE_SPLIT_SINKS, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +GST_START_TEST (test_wavparse_slave_process_crash) +{ + error_from_slave_input_data id = { TRUE }; + error_from_slave_master_data md = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE | TEST_FEATURE_RECOVERY_SLAVE_PROCESS, + error_from_slave_source, setup_sink_error_from_slave, + check_success_source_error_from_slave, NULL, &id, &md, NULL); +} + +GST_END_TEST; + +/**** master process crash test ****/ + +typedef struct +{ + gboolean got_state_changed_to_playing; +} master_process_crash_master_data; + +typedef struct +{ + gboolean got_error; + gboolean got_eos; +} master_process_crash_slave_data; + +static void +master_process_crash_on_state_changed (gpointer user_data) +{ + test_data *td = user_data; + master_process_crash_master_data *d = td->md; + + if (!d->got_state_changed_to_playing) { + d->got_state_changed_to_playing = TRUE; + + /* We have two identical processes, and only one must crash. They can + be distinguished by recovery_pid, however. */ + if (!recovery_pid) + g_timeout_add (CRASH_AT, (GSourceFunc) crash, NULL); + } +} + +static void +master_process_crash_source (GstElement * source, gpointer user_data) +{ + test_data *td = user_data; + GstStateChangeReturn ret; + + td->state_target = GST_STATE_PLAYING; + td->state_changed_cb = master_process_crash_on_state_changed; + ret = gst_element_set_state (source, GST_STATE_PLAYING); + FAIL_UNLESS (ret == GST_STATE_CHANGE_ASYNC + || ret == GST_STATE_CHANGE_SUCCESS); +} + +static GstPadProbeReturn +master_process_crash_probe (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + test_data *td = user_data; + master_process_crash_slave_data *d = td->sd; + + if (GST_IS_EVENT (info->data)) { + if (GST_EVENT_TYPE (info->data) == GST_EVENT_EOS) { + d->got_eos = TRUE; + } + } + + return GST_PAD_PROBE_OK; +} + +static void +hook_master_process_crash_probe (const GValue * v, gpointer user_data) +{ + hook_probe (v, master_process_crash_probe, user_data); +} + +static gboolean +go_to_NULL_and_reconnect (gpointer user_data) +{ + GstElement *pipeline = user_data; + GstStateChangeReturn ret; + GstElement *src; + + ret = gst_element_set_state (pipeline, GST_STATE_NULL); + FAIL_IF (ret == GST_STATE_CHANGE_FAILURE); + + /* reconnect to to master process */ + src = gst_bin_get_by_name (GST_BIN (pipeline), "ipcpipelinesrc0"); + FAIL_UNLESS (src); + g_object_set (src, "fdin", pipesfa[0], "fdout", pipesba[1], NULL); + gst_object_unref (src); + + gst_object_unref (pipeline); + return G_SOURCE_REMOVE; +} + +static gboolean +master_process_crash_bus_msg (GstBus * bus, GstMessage * message, + gpointer user_data) +{ + test_data *td = user_data; + master_process_crash_slave_data *d = td->sd; + GstIterator *it; + + switch (GST_MESSAGE_TYPE (message)) { + case GST_MESSAGE_ERROR: + if (!d->got_error) { + it = gst_bin_iterate_sources (GST_BIN (td->p)); + while (gst_iterator_foreach (it, disconnect, NULL)) + gst_iterator_resync (it); + gst_iterator_free (it); + g_timeout_add (10, (GSourceFunc) go_to_NULL_and_reconnect, + gst_object_ref (td->p)); + d->got_error = TRUE; + } + break; + default: + break; + } + return TRUE; +} + +static void +setup_sink_master_process_crash (GstElement * sink, gpointer user_data) +{ + GstIterator *it; + + it = gst_bin_iterate_sinks (GST_BIN (sink)); + while (gst_iterator_foreach (it, hook_master_process_crash_probe, user_data)) + gst_iterator_resync (it); + gst_iterator_free (it); + + gst_bus_add_watch (GST_ELEMENT_BUS (sink), master_process_crash_bus_msg, + user_data); +} + +static void +check_success_source_master_process_crash (gpointer user_data) +{ + test_data *td = user_data; + master_process_crash_master_data *d = td->md; + + FAIL_UNLESS (d->got_state_changed_to_playing); +} + +static void +check_success_sink_master_process_crash (gpointer user_data) +{ + test_data *td = user_data; + master_process_crash_slave_data *d = td->sd; + + FAIL_UNLESS (d->got_error); + FAIL_UNLESS (d->got_eos); +} + +GST_START_TEST (test_wavparse_master_process_crash) +{ + master_process_crash_master_data md = { 0 }; + master_process_crash_slave_data sd = { 0 }; + + TEST_BASE (TEST_FEATURE_WAV_SOURCE | TEST_FEATURE_RECOVERY_MASTER_PROCESS, + master_process_crash_source, setup_sink_master_process_crash, + check_success_source_master_process_crash, + check_success_sink_master_process_crash, NULL, &md, &sd); +} + +GST_END_TEST; + +static Suite * +ipcpipeline_suite (void) +{ + Suite *s = suite_create ("ipcpipeline"); + TCase *tc_chain = tcase_create ("general"); + + setup_lock (); + + suite_add_tcase (s, tc_chain); + tcase_set_timeout (tc_chain, 180); + + /* play_pause tests put the pipeline in PLAYING state, then in + PAUSED state, then in PLAYING state again. The sink expects + async-done messages or state change successes. */ + if (1) { + tcase_add_test (tc_chain, test_empty_play_pause); + tcase_add_test (tc_chain, test_wavparse_play_pause); + tcase_add_test (tc_chain, test_mpegts_play_pause); + tcase_add_test (tc_chain, test_mpegts_2_play_pause); + tcase_add_test (tc_chain, test_live_a_play_pause); + tcase_add_test (tc_chain, test_live_av_play_pause); + tcase_add_test (tc_chain, test_live_av_2_play_pause); + } + + /* flushing_seek tests perform a flushing seek in PLAYING + state. The sinks check a buffer with the target timestamp + is received after the seek. */ + if (1) { + tcase_add_test (tc_chain, test_empty_flushing_seek); + tcase_add_test (tc_chain, test_wavparse_flushing_seek); + tcase_add_test (tc_chain, test_mpegts_flushing_seek); + tcase_add_test (tc_chain, test_mpegts_2_flushing_seek); + tcase_add_test (tc_chain, test_live_a_flushing_seek); + tcase_add_test (tc_chain, test_live_av_flushing_seek); + tcase_add_test (tc_chain, test_live_av_2_flushing_seek); + } + + /* flushing_seek_in_pause tests perform a flushing seek in + PAUSED state. These are disabled for live pipelines since + those will not generate data in PAUSED, so we won't get + a buffer. */ + if (1) { + tcase_add_test (tc_chain, test_empty_flushing_seek_in_pause); + tcase_add_test (tc_chain, test_wavparse_flushing_seek_in_pause); + tcase_add_test (tc_chain, test_mpegts_flushing_seek_in_pause); + tcase_add_test (tc_chain, test_mpegts_2_flushing_seek_in_pause); + /* live scenarios skipped: live sources do not generate buffers + * when paused */ + } + + /* segment_seek tests perform a segment seek in PLAYING + state. The sinks check a buffer with the target timestamp + is received after the seek, and that a SEGMENT_DONE is + received at the end of the segment. */ + if (1) { + tcase_add_test (tc_chain, test_empty_segment_seek); + tcase_add_test (tc_chain, test_wavparse_segment_seek); + /* mpegts skipped: tsdemux does not support segment seeks */ + tcase_add_test (tc_chain, test_live_a_segment_seek); + tcase_add_test (tc_chain, test_live_av_segment_seek); + tcase_add_test (tc_chain, test_live_av_2_segment_seek); + } + + /* seek_stress tests perform stress testing on seeks, then waits + in PLAYING for EOS or segment-done. */ + if (1) { + tcase_add_test (tc_chain, test_empty_seek_stress); + tcase_add_test (tc_chain, test_wavparse_seek_stress); + tcase_add_test (tc_chain, test_mpegts_seek_stress); + tcase_add_test (tc_chain, test_mpegts_2_seek_stress); + tcase_add_test (tc_chain, test_live_a_seek_stress); + tcase_add_test (tc_chain, test_live_av_seek_stress); + tcase_add_test (tc_chain, test_live_av_2_seek_stress); + } + + /* upstream_query tests send position and duration queries, and + checks the results are as expected. */ + if (1) { + tcase_add_test (tc_chain, test_empty_upstream_query); + tcase_add_test (tc_chain, test_wavparse_upstream_query); + tcase_add_test (tc_chain, test_mpegts_upstream_query); + tcase_add_test (tc_chain, test_mpegts_2_upstream_query); + tcase_add_test (tc_chain, test_live_a_upstream_query); + tcase_add_test (tc_chain, test_live_av_upstream_query); + tcase_add_test (tc_chain, test_live_av_2_upstream_query); + } + + /* message tests send a sink message downstream, which causes + the sinks to reply with the embedded event, which is checked. + This is not possible when elements go into pull mode. */ + if (1) { + tcase_add_test (tc_chain, test_empty_message); + tcase_add_test (tc_chain, test_wavparse_message); + /* mpegts skipped because it goes into pull mode: + https://bugzilla.gnome.org/show_bug.cgi?id=751637 */ + tcase_add_test (tc_chain, test_live_a_message); + tcase_add_test (tc_chain, test_live_av_message); + tcase_add_test (tc_chain, test_live_av_2_message); + } + + /* end_of_stream tests check the EOS event and message are + properly received when the stream reaches its end. */ + if (1) { + tcase_add_test (tc_chain, test_empty_end_of_stream); + tcase_add_test (tc_chain, test_wavparse_end_of_stream); + tcase_add_test (tc_chain, test_mpegts_end_of_stream); + tcase_add_test (tc_chain, test_mpegts_2_end_of_stream); + tcase_add_test (tc_chain, test_live_a_end_of_stream); + tcase_add_test (tc_chain, test_live_av_end_of_stream); + tcase_add_test (tc_chain, test_live_av_2_end_of_stream); + } + + /* reverse_playback tests issue a seek with negative rate, + and check buffers timestamp are in decreasing order. + This does not work with sources which do not support + negative playback rate (live ones, and some demuxers). */ + if (1) { + /* wavparse and tsdemux does not support backward playback */ + tcase_add_test (tc_chain, test_a_reverse_playback); + tcase_add_test (tc_chain, test_av_reverse_playback); + tcase_add_test (tc_chain, test_av_2_reverse_playback); + } + + /* tags tests check tags are carried to the slave. */ + if (1) { + tcase_add_test (tc_chain, test_empty_tags); + tcase_add_test (tc_chain, test_wavparse_tags); + tcase_add_test (tc_chain, test_mpegts_tags); + tcase_add_test (tc_chain, test_mpegts_2_tags); + tcase_add_test (tc_chain, test_live_a_tags); + tcase_add_test (tc_chain, test_live_av_tags); + tcase_add_test (tc_chain, test_live_av_2_tags); + } + + /* reconfigure tests that pipeline reconfiguration via + the reconfigure event works */ + if (1) { + tcase_add_test (tc_chain, test_non_live_a_reconfigure); + tcase_add_test (tc_chain, test_non_live_av_reconfigure); + tcase_add_test (tc_chain, test_live_a_reconfigure); + tcase_add_test (tc_chain, test_live_av_reconfigure); + } + + /* state_change tests issue a number of state changes in + (hopefully) all interesting configurations, and checks + the state changes occured on the slave pipeline. The links + are disconnected and reconnected to check it all still + works after this. */ + if (1) { + tcase_add_test (tc_chain, test_empty_state_changes); + tcase_add_test (tc_chain, test_wavparse_state_changes); + tcase_add_test (tc_chain, test_mpegts_state_changes); + tcase_add_test (tc_chain, test_mpegts_2_state_changes); + /* live scenarios skipped: live sources will cause no buffer + * to flow in PAUSED, so the pipeline will only finish READY->PAUSED + * once switching to PLAYING */ + } + + /* state_changes_stress tests change state randomly and rapidly. */ + if (1) { + tcase_add_test (tc_chain, test_empty_state_changes_stress); + tcase_add_test (tc_chain, test_wavparse_state_changes_stress); + tcase_add_test (tc_chain, test_mpegts_state_changes_stress); + tcase_add_test (tc_chain, test_mpegts_2_state_changes_stress); + tcase_add_test (tc_chain, test_live_a_state_changes_stress); + tcase_add_test (tc_chain, test_live_av_state_changes_stress); + tcase_add_test (tc_chain, test_live_av_2_state_changes_stress); + } + + /* serialized_query tests checks that a serialized query is + handled by the slave pipeline. */ + if (1) { + tcase_add_test (tc_chain, test_empty_serialized_query); + tcase_add_test (tc_chain, test_wavparse_serialized_query); + tcase_add_test (tc_chain, test_mpegts_serialized_query); + tcase_add_test (tc_chain, test_mpegts_2_serialized_query); + tcase_add_test (tc_chain, test_live_a_serialized_query); + tcase_add_test (tc_chain, test_live_av_serialized_query); + tcase_add_test (tc_chain, test_live_av_2_serialized_query); + } + + /* non_serialized_event tests checks that a non serialized event + is handled by the slave pipeline. */ + if (1) { + tcase_add_test (tc_chain, test_empty_non_serialized_event); + tcase_add_test (tc_chain, test_wavparse_non_serialized_event); + tcase_add_test (tc_chain, test_mpegts_non_serialized_event); + tcase_add_test (tc_chain, test_mpegts_2_non_serialized_event); + tcase_add_test (tc_chain, test_live_a_non_serialized_event); + tcase_add_test (tc_chain, test_live_av_non_serialized_event); + tcase_add_test (tc_chain, test_live_av_2_non_serialized_event); + } + + /* meta tests checks that GstMeta on buffers are correctly + received by the slave pipeline. */ + if (1) { + tcase_add_test (tc_chain, test_empty_meta); + tcase_add_test (tc_chain, test_wavparse_meta); + tcase_add_test (tc_chain, test_mpegts_meta); + tcase_add_test (tc_chain, test_mpegts_2_meta); + tcase_add_test (tc_chain, test_live_a_meta); + tcase_add_test (tc_chain, test_live_av_meta); + tcase_add_test (tc_chain, test_live_av_2_meta); + } + + /* source_change tests checks that the pipelines can handle a + change of source/caps. */ + if (1) { + tcase_add_test (tc_chain, test_non_live_source_change); + tcase_add_test (tc_chain, test_live_av_source_change); + tcase_add_test (tc_chain, test_live_av_2_source_change); + } + + /* navigation tests checks that navigation events from the slave + are received by the master. */ + if (1) { + tcase_add_test (tc_chain, test_non_live_av_navigation); + tcase_add_test (tc_chain, test_non_live_av_2_navigation); + tcase_add_test (tc_chain, test_live_av_navigation); + tcase_add_test (tc_chain, test_live_av_2_navigation); + } + + /* dynamic_pipeline_change_stress tests stress tests dynamic + pipeline changes. */ + if (1) { + tcase_add_test (tc_chain, test_non_live_av_dynamic_pipeline_change_stress); + tcase_add_test (tc_chain, + test_non_live_av_2_dynamic_pipeline_change_stress); + tcase_add_test (tc_chain, test_live_av_dynamic_pipeline_change_stress); + tcase_add_test (tc_chain, test_live_av_2_dynamic_pipeline_change_stress); + } + + /* error_from_slave tests checks an error message issued + by the slave pipeline is received by the master pipeline. */ + if (1) { + tcase_add_test (tc_chain, test_empty_error_from_slave); + tcase_add_test (tc_chain, test_wavparse_error_from_slave); + tcase_add_test (tc_chain, test_mpegts_error_from_slave); + tcase_add_test (tc_chain, test_mpegts_2_error_from_slave); + tcase_add_test (tc_chain, test_live_a_error_from_slave); + tcase_add_test (tc_chain, test_live_av_error_from_slave); + tcase_add_test (tc_chain, test_live_av_2_error_from_slave); + } + + /* slave_process_crash tests test that a crash of the slave + process can be recovered from by the master, which can + replace the slave process and continue. */ + tcase_add_test (tc_chain, test_wavparse_slave_process_crash); + + /* master_process_crash tests test that a crash of the master + process can be recovered from by the slave. I don't recall + how the recovery from that works, but it does! A watchdog + process replaces the master process, and the slave will + go to NULL and reconnect after it gets a timeout talking + with the master pipeline. */ + tcase_add_test (tc_chain, test_wavparse_master_process_crash); + + return s; +} + +GST_CHECK_MAIN (ipcpipeline); diff --git a/tests/files/sine.wav b/tests/files/sine.wav new file mode 100644 index 0000000000000000000000000000000000000000..9d8108169237ee84109d8c90c5650e09c7d0cdb7 GIT binary patch literal 577592 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 CkAjZ? literal 0 HcmV?d00001 diff --git a/tests/files/test.ts b/tests/files/test.ts new file mode 100644 index 0000000000000000000000000000000000000000..62821b4b0e056119c5227bae74e5fac8ae5df666 GIT binary patch literal 400628 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 LgQ6yMS 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 z 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%0Dt+KhsW>QaOj@?MP)!vj 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�a7o zO)ec=C>;${2vnIAEC4t&f%W%#N_+mdddm9uda8>P!C#+AE+EF<4V8E&4Ertk6-gkP z{bnYW1x+4u`anBQFo6+%5K%=^=8|pr`|=5xljBsYxhS|H0_k~?&m~8A<%wqb37a1} zF4_(_gs0q^#c&E4LG@2a`K#Y-gp?bI-`|_?U0eL}=lD;|v0#lSsIY$Fv?u-aR<$ak zS0T=)#FiO&nsd5VL>e7W*T4Dku@@1$BQ)~IQI!1V-cau=l$BPUk`)mSaxMHx^XWUh zbIN=+Q%yj4Ck|>yerD4G&Q&V!pRS9{gmI!9^m(5P9-}!xuRU*`J$41U{Unyi0udHD z-NrZ!ftBta(!&anBT^&yDc$K-CMwgl3t>ii_JI4jh!a1UME!n5&<++r@Yg(l?wj2R z1~VMuz*;?2OGC3t!~OQ@>nUkGT*k@y+1PdwmlJ*@$y&TxF!fiblSc*KTx`}8dADjx zAa)!Va*Z#G0br)FOP<*@UTUKdOB%ti$QSsU->+uU-*a+vh?vAj+%!wqL3Ey-br(?p zW|5vt*ZAyw<*|+4I9I#$Fz*aK3(A?s7&de5YhhQg`T(=A5ly$xOqn3~VfGw{0j|z+ zn7$2c3f&H}; z>e~}Dq!|`hq_A#6Ozvml8^77eU-S59E2mJ@H{_fDp!{d#s+4r*YFp1X?>|rX1B4qO zbth%p%ZYj#ui+VA;`KjOMT^+*SBGrci6rBQG9E3$uY&!a>M7)bU~N^gkbgcCR3SG* zV9FkANchpuyH9}yVC6naKART?x5I-i6MR`KetF<0$>G7LXtUu%ErWm652pv|qU{Yopet zeWVjp{Vx}}sH%G}dz}0y2QfY!EMtgly{n6!aO`B571tZ85V|bW2JSau;Ak1K4hhaE76bf2ImpAiT z^chA~D^B+P3j_<6>*#8QFUtv`_fH~*3~@2xp#U-tT9;wl+62wLOKbKhagaue`Edq!(d#i%MP*#&( zaxGN5ThjYzj!hOJ{Xd63ykeF}G)v=Eeo zv79`bfKM^&IqfHu~plE{wbi>KE zNsAG&siJE&j+Kv+2v*%q6OVO{n=htwD{=E{UcXKNg~;j)OS(a?)+(QxtjHLh`6Q2^ zj9S^GW_ifoK*e&_Lav%4d20(_;B9VA}tly82)CNK)FD@_~

Qe5hZXU+hzLHy#ebg+kZR9(2zy@pV|Q@P&+_{g$yPE`jkab zp(hMlj!)mR-72>{Jjhe$WkuxLI~QcX*Ulau1fJ(n!~{3kt!b)rsdM~u&$Dn@{v7rk zj;pfJa$RAdaI*yEpt4<~WW@~R7`@gKL=amYAWA45v>s3g&;m7LL;(+o_~>!4|0`Yy zL*eSb-~+u7KuREm30&XQCxROGbJAb>={QEOqm815Q3?ykHiL1PYpj{k;}MabVew&| zD`vdbMe(0T2;jVg+L79Ip5JrJ`swq1*8S?ezT5qI*H4xEHrZ(`bY(|n(CrjJfk-~k z(+SZB0JKtr{$ocq^T%1cJvZQgI%|s<{*4=`{GA(kDOjt>o13vQhiht@`}N&@6B5Ah zQ+Fq4w<_t3iAU?!>C$Qpy$L|5HT*+>H+E0+`_Qg`H_7C@NodoPn&o{!=m(C_S+|8l zlm#2!O)z^YjmMWF?z(2QYzm~^QXZE3lQxuIKT#1yxErF|gGtTRCkOHen^Jn6#vB|E zWM2y$_;+!2vQA^;R2ty@jzZl1O-dwS);$>wmC}p%y*TWajLlxoCC9F;ffv!nKe*1VTttnaObNL=teaTb{xiZ~O9%}E zJEy+-`rnE$5=vEr-J_GC)*8We$?>^I)4e&Vb+g~k^n!B0uvk-BJ2|ah74=9@Ams_2 zYZ2sx2t()0Bu`OmDJ6a>Lk{LpH0rW&a^%PU;B;5*oaFeyu?elQU2J>VMxO`7j%u*$ z(-n(fe5PM688eR%0;`IlFt980z35AldUIA@+MLPgTCDc0W3_b(2aSm zDgF3M$dD`@uA~ZTtl#T3h_x480KH-Fb+$+~*&%1}hSoTcVyqSInEq5nihW%tgISOD z3PH;}nuHrXU1jjOL9gwAdlT=WsV^{{soWUCKXZAmm&RHX9?MiRa*rdl#cr* z<&1)2yD(XVr%I5*6&|5C-NyMc?0X|(pK=4SqgnmYh)8^Jf+E&WFM1~qHiMuuxEWwM zyO7ZkpdVc8)Jp3x(++UQ4kRbv^&jrDmhJh*3&+mvo`|N0*rd?fP3AN)`VQy3=7Rn@ z7>hFyl33+HhYtT+eP~%WrjiPw|LDQA#y9FFISE{%+)yma-Li2-YyUyJC51d1Q*>u- z0;91lc$wGfD`rDf@w3I)LW71=fk8_}#7TpE8Vdf~FGQ2moS7Os{K+W)MiX(ZBK-Lt z$i>@mxSv4m=(cgm5i5!I03P(&nMYhFn@hLLXctk((Pi-@;pi=WE68%9fosAE(RJgY z28EWs9|-ek7xr~A8H?geZ5ZF0DJqOA( z`lr`LS0zhlG~{rly`*=d0D#yr#{~zE+SdkpXuJUd_dF$s4{_-4Y9)XRv+LZmZ_qTh zv<#g+gf3cY68Ua@m$~O-YE2C3M-FXXtL?W*}4J1vgjlvGWTn zcQQWRth;vsz1?IUfOhBRedJ^U9!2V4s%{W8QT!Qpv+I4O8gv%S>RooKdxZ=%UK31e z==O+5?VRSPl=PPdr>I3Y`W;CtUe=oTG;nUB_s*FeUXSVoiX{y;Fl>a!3FL0uh(}Qh zfz7s4nW@zc28l18ly=GBOCEAUBHANC;Iy?AZTj|uWZ5(=@&F?Il#$BWTvZ>SRfO@# zNxyL6;xKqZfXR5ueu11psM=L+_&Mh%0(fS`wJ>a-RlZ`lVasqiCK}<}j$tGZ4 zCmLDErV1b=0wHn%CrEi*upYWRx;F6p^S8dBm1Uk-V2frw#0tVDqbY;w~Cu$YM~_V zazGfVykniek>W=YJKc>R3SwdKZVM0y(7l41zLPl7ID`nDMLAaBNBHdIC!%Vr{yvHB zc@k7+QE4onIWdoCIU~iZz+@f~#LS}LLqxSif2k^i_lbJ%c;RPVlI9$JM@F_$X6n8V z(p&6H;&!>n#zo3_VKJpmHlg#Fu#S#v8n?rj%wsO$t83xaUFJ`gGv@b=SmHFM2F>_2 zZDc77=Ho<1Ww1in%3*j{Ao9x4=NupYNIX!_wO^W#AzK$YAkeb*oLBE`mFIl{@28)V zC#~T*P_wF}#u-E6I#G$Oitc7+ZK&+%Jd6edIYw=?D0Ur=Gy6PbA3a)mgINwa_KoB8 zH-@5WNe8z5oYYc)&go3zRp@$UB_|^QZJWn56-3-;jAs4oR`e!klV*Onw|y<2=a;VP zHg4VwBsNHrb)&*9i1w<<<8P+^a^G=n=;+?6r3>b-D!$#UchiE~uhcff0=~+1Rw<25 zaeegP@e@FnKx@PB?+&;Y)^+J>-so4-7v3InR6$&uuC1o~2XQ1Kb0=#uBZ^q1`nOMh zv6k;b;*Z^V*DnfwN>W&zXI{q~2p!FiEmh5kva5T7)V|#g6B2sNTA4p}mL!u7Hh@H= ziGjT+-@n~UA>jB;SolmFVIlMrbwz$%pMLf-h=QK_bd1lB-Ne9=v{rUS-^ev0gaWpZ z%D3CQocA?hiPufZ*`TyOvWWQHn5p5GOOt8fQqGRP_8Ewspe^Bd4_~m(5Qp+-+Oh*P z+X5Zk;5p>^Ua-2aQsg0u-JCfQ)={uu>1D3wZ74NM5#e&u+DbCa+Ob(AvDjfyEgduH zf4q+0_S+L{=spC=Kk(l0P@pueIhtnf^-IREab6cgK({*v82QJzS~QWc%l5lsspj6s zTPm!VaWivH&Bpn7%m?J=lU(UM*GF2F%bOSua4?iJhz60;L*zWRZR%lUplYrRF?{Xu zU@Ce(CfI1vqdN2ad1-J1Z<3dBy7;O8wR z0(w?;fdy`|rLaUJQ4#7j!ayvRv~1*0y-g!vLr&dW6477ut1?NDGdTp&&7N|IQ(CsY z(o7_vu3y_rWx&YXy|3TAaRwr`$v2jb*=6nNmgj{uAledontC2<7SCe;+kQRMSv@?y zv74}jskCYtCML0tng8e7@Rf7IjQwLhEY(YN6R7k zDiGkx;fKJliZE%NJ&h1vIbyk)`1Wa$#BvRiu@-zCzR7th#=R0e@zdGsIV3hs#%FUo zvXv{F0M;r$PTWY}Mk(p_)Aj#qTLu{;=MrBS)p zY8^YgIp!YA|#X{CEq)415vJ zO8k3$)mu;;bOC^qq5(=beWbGpijFx0bOMc2PpvK;&ki+14VQG>kHEjy2@Z|59ja&3 zFmrh7)+3m}>}~%>w|9Nfncf{o?BVV-6^0Sqo0i*Anx*tl?anpMlWMlv`3d&pdxNz< zD1@QMo~2#0fwJoDtJjFs=KQ5Q{K<&dG1wV zcdV9Lv=FXz2D9{GYiA=q^x3?3%`J=}mC&9|J*5(326g&eoGdMgdAX>1hy%$j(dBjo zJLbllLRrw|lne$C+Q446kdN$obm@~*XXWtElDnbWU3M*UJrOJQMAYrE^WuPB;7Xt5k~1|jdg3+h2(X;AONJdBxec< zTly63x08FNy~EUe&vvZg5Xvl%wFBK*%)~oU1#?&CbB#YU2r;XXa*UT%B`IKE1T#XOQ@4}c(Qf^Id5gS|Jtz4;ulRir+75KR;HHVGC43rM7$KIVh zHo`^jq~zk^?5IS8wQ=;9)WMO;3o$5iYFq$&KJbXMPk382PggTyUoSPUXK(9wrPT)& zcKm1viEVPjbGX5-*3>B4jNei4$gR=L?zlZaav?C!*E+abFRqkf48m!aDpVAG8;&)%BL>)Y*y)$4$p-RG7v)$@Uts{`!%i02f=8H9+LnAhRE~?x07AQWg+Yg z;%vro@FNi~5IYtrwnbH}eKujcFB)P(&x5w=ca&TA?}4)Y$4jXG8!E=I-+dsi8^sY< zacO!kAg+e#bD6tUBqyCrNp0E;Hwr7Ld8H05y>}OJ+Gnag-3zRv3dyU-d2z6UeOr3X zUP5|%j6nsOuTjcwe^^bJUEQtqILs|IAiXQS5PhP=q^}L@2#Ewm_#?d>8PS1@YJluuBZ!B?!3z}7T5mOWmZ^1ljfyW$&3T{ z54487x478KI(EHly9cb_pBQ<%@{Ld>_}A<30A>5%ku?>NfxLCC?0slYCUQNH@;rlj z9nVH93f;UklR+%=UCgtoZF{c>{t^!9j6ZS{Eq5!J$nhZ?3}XBgl%%Q=nJoi4zC|J; zx=UB@&YB(-Q0eDB!To4>(tr*HV#itAZ8(J2O4jb+c-Y+>S(8@~sE8GUo?|&Y z9V=QJvw%{sv~+V!cd>$!{p`LHB}AEfxLf}s9e94_~A|!)by{`BssqXdxRLkH!TC4G!@s0-~|kv?^#k@C%r|r7-wpc9E6Z zv$6Y-^2mbHnq6c+JlMcR@*0>#Cg6Kag(*|M=2MIarR-1xb(cd-$}VBSt5v#E^N2kV zJFnUQjy?ey&Gf@5e)Pg`KTw!+T8JyjhYsY#WmM^KmTT-s(U8MqQ=2ho#Ddm05d1XN z&cpjL+ObQfeluSGYgQF$gwiNxgh8}bYBnP;>WOOpNdeN1%4A?&<@(q1mJFRsKWgho z-V(3_|KW{HCn1i>=ze~DeK^*v>_}}IY%WK&C@yLFf>d(4A=I*wC=t0>YtYUyBmN)C zfs)OCPV+_UvMwzXBuH9kh2Ay#U|8;+719p8tZM_X5I-0d0kg3ZBdExu2K&ZqN!$m7eQJ1CApOjyKv5 zEH2*Gg6-pt;IiG$&p&CZw5R-2KA7Sy%~378p5oq+ZCTG+?0!P;Ix9?GFL@4KY=YH8 z*F#wcaRos1szLk=ps#}vG6;bA%TIv!cP|$SSL*-5TIf0DhFBt7U*H5_hu}`>Lj@R2Lrot zxf`KxVzjH1+UlB^Bqn|S^gXWki}ZdRx~pOAMdFN7C0lL+R0p;vGrQo9cuGbR8;*ZV zGFP1H#F0`_&%ag`1VA|do&jKSGR+f2;hhk&i#MA> z5$b6AKnriBPvTi$4ZK>I44l!^>uGJzO6G#=^~ZHUGT8h^Z2izE3F=A3MXfBS09ZD7vtQ26J8y2-#|ekx-L}n^MVpHfh@toC9Rs7OM&uT{WmDy={u6%WZ)}#~)rU`IS z8P3&zlu7ty^jKAg_J?|c+o$aMz=FwFC|ZJ>JV4iSki!xd{KVo<47bu&kunH5FMcBg zTrah5>e}=ptZt`9@hZW~l8EIlG;r9)SQ3bxP<89F?jRH+(0F>;;(hiFj@gRNvX<)E zjULRd(zu!m(vXoP9GMJaJrRR#>1Uh^_Wh^F=XFNU`7n%x~_- zccm0*sxM23pFAz(3*dw2{gN>(Coi+DbyfDfg)FsR63r&V2EHN}ho<1sp0zeIMi{Yk z8+{Ee#QeMzBMED3;Fz0gsu@AtUM$XT#rKHFl7&i!Jd*I|J`Gt%VL-@EWa2J$Le(-p zZR#v3{G*3WG;%CYmXUG?t`xwtkY;2JwdjHMJYcRxXTfraz`J?5ZfSi$g=;e)>4#Qj z>;OoL$wwk_i^ZW1t!yqv4B3mCJcXSHFXSWoMK|Apw(c<9&Y?D6z*WXZ1aF4E7*ctm z40g}tanIxIidsd(dO0d>&t77b{)4RY5BiU9GRez!;?&qbd7ftSWMI86bP(ztHUGa@(ukn z<5W8=IO<>!z*s ztcqh4R)+C(3F+rkt^A;*CeGf81qZ>ijSFl1O~iq{9Hvr{Ink(Ae@N```y7heV%PfQ zg8lIZhVZGYU8QYd6=Xc~CyU21EEEAdI4PAkJ>5n{H;5ej4qJS$IWfaZhjhfb!!aNl= zEN~nz$D$UNAgOcYM&Xa&gR=f?6X-27H}kEq;?AfA z^8Ruim1S&Y8TvfxF+&Y%uQyZuFy%)Q&y`*M#T6;%IFZp{Ry-|PRQCR&r9zne2M{~z z4iVh_B*ytkkdpLu*d$m_R-TYfgR2mw_}bn&mw)%CY|7e&fm{CbU-BUdVro;{&h*q9 z(a}3vesbzEm%>xFcr7*Dn+X00*+;fHwme%>2L`G-(G#$Y2b}anvQQX2e5hw!gYukmh~Q;^vvKVXPDs9$F-#H0oK)jE!)^IN%61a zHqn1%8>50pk&wpfPJE0VR2$T)EMig2rD>+oplVc#?l$aJ2kz@G>EP{7Ok8P>8UkNf zyJhw?e;U7>-Rr-cy?G+JKlkJ!>^J{ebG+`QInxM+5M2W(0}5{eOn?Bae=KlPgM|>H zMgFL(0N#IN?SS{+SUX_<=yA+`%zpl@$B|F+H(oRQcV46WIU6Z$n~@! zvP&uniGgz^g}#x6Hwhv)h1#GF3i^$j1wEs*_qA;w7isY!+lc7yXxH@nBoZ*G9(mKG!do8ZC+ zG&gYc{%vjkofG>JvOG30X5eoXqlKbXwUJda7*Hv<*fy`G%oSLo@2vmTV2D4)xng7U z(*^$L3z_@mdUjm&&rt0`E6dIP$sV5=e4$+iK=3vrRC%WhO z`ZcbIoFJ?Fy97;bz2A_ZFM;(jN|wO!E+0%z@V0}JL$d)}LyX-0#)knbos(sH)2KHa zAlK6;5acSX>rGj0?!X=~2QWV}%9dOneh@FS-l2KecaWY`!)|Kbur?cEb0<+5Rsmwi zTm_>euwc`dj`Igl3qH-u5QsIerLw8=Wmk1~Yv--yWrjJN4ZpCr*7&4^y0??LfmX?J z$PzB|RIIQeP_x;zdiB*g*`M40qxZjjP7Y zboRn2B>rHEs*arBtA@Dpcljbl(tnq?U+vvf6#4K)VHxJu=yq!It9?I0V;1*cPedH~ z@yS1OWR<4A^2tFW_Z?{eA6(iw>(_44@35u-V#gxn8D-wtf&c;Fo|ow*p8>$Qc{=H! z+4)#?msNbOR_!a38ZVY-()O*{4`lUzj_i&h%g4K5GDe48-H0)hK*ifxR@t*W2B#nE zSQ-!oV+(U<+r9n}F5gG3z^@{wC%UBmp4e0mIVrM8@jI$0<&5O|%8EyG4YP3$OAx!3 zPDqEOERCh-Y=weDHwmd-Mg>eVGA+7)^D+}E9Q_cyWFWHE>~S?i_;6YJtQ-%ch_pV( z!ng+{tTPvg9Xr-5JPgnDNk1{3Z~Hh{3ceQ{C0&6V?usdpGUl8Ghib5i3Vv)L!Z)wZ znRXb1pR+Ku#+4z5ox?$Vyd_Je=0}#~ef&Ni^ktQ{CTak130P{uX3AG;K^w7#g9=V! zsIj*ySVUqlSXoaR{ufH>Aj&-Z44e7kx=(PthWDot*DsI98M4l_4hDSd$vUF?&$q

Fnt_4jHEp07?s_#D`0kn!bF^Z>(DojURnr9C?G>=5)tDKJduR ztpag|I!&s%i7uwMY}pw$IP)o!*-MDy1let2l-aI zpU1*vE}JUeOh(dt4c@h%oC(B^EBTsL@HH;(mpe1x7!%3O=8kr|mOnU4bGzb=nT7_Y zn)g=-`reWp_^Z7ydlMQ#!z$H_xfiK>oQSL*t<@StE4qaI&4!g12EK~n+H(nDp9eWW zhp3xMLTHuLt1%b_QVW`wI>z|czl~rSTs3Kz)8_O;7H1P(6ULcpF1izGazLPMqr!W&y;G z_a_$2BI8s!i?tr1-wIj7BAM;0ze%Lx`h=>o9$olYj7S|^pU9JbTMXO&AG?Wddio37 zRhPO9a#+fztO-=|VbmvaoeI~^>A^&Fx)RO2hD0vTe1=gqf7tvl0X$ztb#IDIk)0)2 zOTuh*)F^}|EfRkw#}G?nn_NTIlslkjy?U;2v3C!WT2iW+26(eRxczMLG@9_|a%1on z;d5N`MxH@$<(<;Fk?7{f4hWz9u6?(xZZCul`ElmskN9t$wg1a@$N%*gu+D_8?t&pz zzMz-ba^ApJcuwD&b0xh&z>0@|G1XJT-aCpB=1}$MCqtVp>+5+0@)=(G{|ffM+5@5g zXb%(>{6%GYUO?FY+1((4mLg?^?wa!BdwhNRqqBYM!MI3~Rx#?vI-2IreedDdyYVK^ ziv;W(6z=}h8~M@dz^s-kq%I_>R96-w6<3-ILKanN4`Q)aqq{>1mC~j<7l}3XOH7QOp>5Mlrb5)uX+A#I`gZ*J=F<}g)#|dt~|i8 ziP!lH!D-&o%g5jN<%Q_9;adtWbZdI z#tFcr2Ni+|zyxFvg9_1O{ng_j_&XP9iTfKDxcWO6`0zzaf?}#X2tfZVs?D8PW9KOm z9BHFUXINoB5o`L@BhYBxO>XHezk zWK}f9{LYCkV7rST!HXJMqki47t_r;033VeHQ}#T>)J0m{(YHXh5cTUem}^c>1DqUI zxxV|!HSDTSat%`Nyj*Oe>`Sbe^R4#v25o1y!B}9H?roH|mZtqYv&UA-=3Y2eFp@I` z-5EL|1rQ=RNV1h8F2+6Dg_OwRz1QzUG2N(UQNl(8hjN+YaS|a<7^3T70!T*lmhh&( zedgV&H7hy4UE*)NN%^|{X>qOxt?{)1gP+>p%$rgzjl@-~_o~Fe`9P4<4;uG7K9hnP zRFNsCBApfHUyJzyapj_|)Nhmv?zWsMAR7f^eibAw zH15&bax+teYe?VCY1LR+fiEejp3rdvx6@9P9iHZ73f~QU=k(M9AHL84#&>XWn$KAbQKzy8ddjxFQ4&sFz`MU9Sz7Oicl??d-MjzMdyQnI??X#ONLX5;P) zDqez%EnQZAR!N!6vrp5qUm1)#Cnl%L>K#auiV64C$Ohxj>bCe?kX@2Z70Vq|kt?HP zCsYfj#QA5iV7ZIHoTz>N94q9@8Y%kn*%vY+#bDC|2IW5&+LlM-G^kFTDDoUJ^Q&qp zbLtdhuC$_pj(eiV!%9W)EU#v2>c?%5^w?x=T@lzp4FdJlyNOkft(I6@~Is9}@7z8W=A zNM&RL6du}#likdjNiMprh_38T)| z;sOGPS?NWS*2)hNM5lF4zJZG*1w+g%mPIA-fB(rE1+5jQfQ8}z&C_xx9*79X2R#4eRmAl5L`bnaV-*QR;Di!w<&|oFaRWieh6)) z=m!Hio#!#Sw|MIwDV|Oz&BVes+no0wv0xpT{(BqIZa%~kE%6Dg+7LQ~RJ~erd*5nJ z8rdn1@wV7V_~{b_0#KuRj(bwueMGd+W7Wl8B=NH6~a{P z(Pd+aY<#58QFFD*&J3!C&!#^@1LZ(=uxP)}iW=2MsgnL>Qgw3X<^j3%iEAUO_VoKk z=I59Xtqgr9lLWjVKYdl|(*BLRp#Jk*$?yu#Dt$mcLph8gGLIAO-1~)9qhTFLqA`mO ztb8{}ZH+ce7kNXh%F5zJ{Aodhr$IEARoipwmtud=EoJsL$y2$LT}bO%S8$Ex#9SID zgH=q)6qj2=l?E^<>@uOAElN+C3lUJK@4J>#@`I>ZjD;AN{L9>w_^*Ci65wvy?9f!7 zF_uWwb0|_R9U$>$HlYHV_72IA)8S3PeSO%k^o<9}q>P4u*g4AnD|PjMUD^Nt`^4we z9U9UW0?e=a@9%H(!@#=APxoKI{ud<(`v)Z$l>UnnY`lPcm-&fav{! z{?kt|`Tp_tAAW*N)W6qP&plPK5)Dyi$N4;uMkwPt_9=CNLZi?1jYD)2YfeU7YNDok ztq8VDbe}S!x?ETxC<<`VT~i0#IA#-QPCQw7D_|mMO9mB7M`}dzK^C|+nwlZFPiVw{ ze>d0i2$E^1#B=D^N8#JK#PISDYu*-udoD7?oIW{edDMFdWbIQ7h`e8J*B`oLkXZ)a zGgu6n;Z^7N)vfPafsO+ZUuJB}6gP(o5K5ZASNg_(pZcfE@VH zX~a;`tJ976U&V+h8V0lpXmO`;84_D!q)pI~uk{%@JK#Vl59BqWBh*C-gFdFFTXs{{ zPPXSABuQL?yzdfSTsuB>yDIE0kKNp z)VEh9k(ovX;uLXTa}foOnTOB4pn>UW(N=b!FT_aY^)8SU1XAgrX&uK;L>Hum-!q#5 z9lNQW`J)R93m-F}I6+g{PkQHqBYKBcu|FVoT_Yx)vLpPedmF!rFU$+5iWVPfq4%>> z)?dzVhVI}ACQkC|5ESmKaL3#!zT|3l#pKS3LL70xlcezxS}3EF5fC;kjAErAF@u~o z{_xs0!v(Z@Kh%M&LcHsn!x3%bHnN7@5&OX>PD0EGHN^EVTE1~g7MgXn(jd#MEq9~F z(9&*BZy;S3k>(U9Jnlu^MW;79PHB#UGOcke&r!Vm-a9kmq7Yd5@mEf*JJVZJKz~*M zvZ(4%s@^J-=T&%Ror7Q~mHm#26vP&rl6i&kHqudz_=L#xS=eMq;u`|trDedOR!|Ht zr3bD7Bp`Q}6Wq-2@v5Qitlp01HapDg7dfFR;skhsRR%B455f}|iL8D;&g&7%OCb^5 zXA9(P@nl`KI@XrxYu**tIOxN2DP_&GmR51yv77$iKjgMbz1YkuRR|*~D(PRhAEh2K zV`mT^7YmVcHLJ(iEw;;&=u?{$f!7`H2U2@j0iD;0=5S{xLHR_N@edxx4A7P8wk6%T z2R!pXvtpd#m%mm)W%8GQ&d)%qnmKQnVChXTsbOopNX}{vc8z-cpuvjcRF;btj1)k_ zTD!n$sd)@zR*fP~Y8x$h&Z;{ut-fe_Pz=`%)8WPz7B9dF;ngYo3fMRrkJO-7;5{0) zbY6Aus%-HzaK3vDAHj!>lQZ9lANdl@idvkj{9Pj^1&xKeUCFcMQFO3Gz19uB(5ZuF z1&AFVzp>fE+yt7AG)Beh^V3{MC{o}}iM@(h)Mr(=Hb^_$bUbV%iKEi65cEtnRtGt@KGRlVX8n6miv6opZl9f><2J$%)~0Jm`lE@ zwFHWqI;{)QX6xLKdM02KQnX0FvQaDQ{=oTrrvzk^j$fu+qUw8H=LL~4yyvD}$lJd8 z1d>_jyPcC~_Un<)p@b=dxc|3(=+384x>xko8N#JQktr^}U{nKiQ|S zmJBB1!U+3uCe@K}F{$6osGxk1F&;_sOJC-**?qIx5i5AP%W5DVheK;|0tYhwB99oWqHejrC>Oq1|L`FP=>o z1zg#4W%MGxNPA|8FpE)PxjH(%61HYhiad{yv7>H`lLiH6qYpuo(m4#*(rAASfp@N`n*813%IXaC}3&B2Z|@&sqGKva|+Ctz3<;_H>yT(;-se?~nfE*zQniqI5f5AzZut7DS5a74oVm)T9 zw{V9B5~4((t!uQuK9NF>*GpQW``G#Ybj0vfQNqf1BeFc}X{0894Nn04xNN72MBS3cm-4Ehu5 zhtLpY8g)ODm~eh%6>e<0(MxDrMo15J$T}(6d1$sguFB7dkZ(kR-`l}bz z7Y@);Wb(qUUKP`jKlSvUhZL|bI#o@Ndsw< zN%O#(XV$ElpRkpIqp+)e?U4q$W;K9yq-5ZvigLP859~_T) zzZXkpOZET|RZ+6wEgnqxI~6Eaf!NWsx0e~EIK0o-xKrAd(GxyDux4qz_JUhCJA*U+ z(ya5wptm*DHhY7qm=x&e;NmVX;Qg$CfjVwXBV+G`=TKXnaZv(*q>NdbRF=fe+o~g! zFJ0{u;|TqwIhgP3X4M`ur*vW!q(EfD)$2FY&EyJ^3a8Y|I#f)-{tBr*cR8F zfrU7AbUo3(%Xe-SW#A6?Q^KQ=S{NY}y-7Y#0k)4}nf)xgJLfKbMXfwb>tKtVQoz|g zD3_3$qXI>prRo~(FDXhkR84bmpjTj{=;rUMEiOqjAx!wN7A6;;yDK}Yro zP%|F_NKYq+JLCAIyN47X;%jsCw$`d(@yCCU-xmI=&Vdv_j{SKI`CB(7SuR@@Q_SxJ z=d@K0Xkt)DSKvvW?{r-bH4Lh72 zub>;r1hg^v`1*TJEvCuq0|Muj{lQueVLiCa@oJ2j%_Ag0IZ2!(-y+yWnLA=CvN+VC zvU*r^i3BHU2v5+bpBd>ojOJ+3yEs~aJ&H2=pdrap@M4;67WLYR*J)JpCE@M z$XT-nJ^ygM>F3M5VyDQ;6kC5?S4h!Su!#CmNmXFJah1sL1djk=#mHGYBHJ#E`A%u6 zj`^92!JfZirRpiT)`y>$9UBI}v9=_1uG;k z0>)Y{{e_6;k;uaXUUz?%TK$_?$UgHHYgEtwcI=cgzj%3pZV7_rFCzF|M0M!XApXfSTc08qaq;WxGN;p)Pp29gjSu{<%4rvRGWIxI(MeTD^&3iZt%D zXB#DJ{BBlEOeJd=h88a}2asg(g#o|-BvQcvFuw5uASi!2syW{^jw5g2kF>vO950)H zo3D!h(|lc&%u`$xwDH?Zm9Al{X~|)_%$BBdbVU`CG|4KCij#Ik_q4S!Sp57@Xtok1 zs;*QbpPq^Tg+i)(+mofNz9xGewu~&Rvq5XQ_tyJxqB9EB>PM4ngHS7OR8|a(wp`1n zSWK|nK{f7xRtCM+C^dlR4oQAZ#{h1=zER@T4Y>oZOp~E)(BrBd@R`8@E2c6=SK*2r z9zD9puoc))vw@^)xTz%jG~S8u_DTshZU-+|ouYtbORLJ;mwDV;&h* z-5*K*fVYi%jjRP098j3m7cbSk<)Y|TZ5|M)o^QgL#dN7wQd^(kG zhwCQI{45DWk}~W&3%Zjo%F>VCph3?h+7D5jO-)%- z_2CnvR!s%sAlTIAI5kP*V^03JUV8K)#mkZW3BmkoTEFNG*b?==_znyOb$A$MPb-*v z&euh2vy}6&?+@%j$tH6w_iTa^{b-`vhHRvSv|-BLLh|77hVM|>ica`=v0D2ovn&D! z#Ev)Wy{y)ji|w`|z-^RaIy=PAT9#*NmG9GeZnTg9?tJ9qr{T{c1K&N z=76RWlZwWhL?37D_2f9^Y=CCYP`OcBgzm^;-CV*j9MWHbnaMoD$2Q>4(%xUu*45sT z>jX#1&2g47ePymeBeh@3=ZqgQYr=86_ojVmF}z<=PT4=C1|RN#myKJ^_{GwSUh)Q0 zcpeT4K7e5)dhFgeL&~H@q^qLhwC!<{qRrtpT5ko!{^6z0-x?OJxf!!MWme+IF37l; z-8c0b5i&@@P>P7&W(wW+8-i-^YU33m?ieGWQ}}$Pj}&S@^~l=q+#RQY4jECZXp{p0Lr>7u{Ca*; ziNQb(Kh3v)8|PSfrq%ZPgWfKXU>=TzTKNY5hM4!`(NIxB_907z-6$JFbCV)Z%V^Zs zmwE`@RvDIXdiJS`dPd&q=$rc&N3Vg z-X6mLqB?w!`>iMC(3T}x7xlf|mq%!p<7zI)6ovOD z8#9sEoM72eB>|f7bGk0=HG_6cbcVjeJ#m);_pB2In1RB?aD!NvNe^@LSe{XjYj`YW z#6ubJ(3K%LRS$I*uf=%CO4AWqo(yx!U@r*@I%_LAC!5G5{%#VEzwhTwph1;^m<}RQ z0f?P3=l{-J{cn$GmlphT$Rw(ZcHyx%CbZTz17|jY0BW8s4hT?d3 zYS0xjDiwc8V55A{Zq*+wXc8oFoRLWCNImqkaSp+c+f@6E4lSU(R|yyM_#?#;(+t3= zp4h>=Gg3|TNgFA;^at|c;)0I2Y*SA{U(WSd83?Zb87rGu`2Y^u^ zq+T12)#{3RR<~3Pld4&}4nL%wn$OQXT<9b!+OKqKB>nl++9Ifx? zKi2Qi_u;#xwnuwfUY!AbPS0pRD4++pw=4|>0LVoPiWLU5k7#xDIQh?3<9>O^jvA-3nIaz10yPK{lP(y#W@(@w$Ab1`IF0vPP)bpDfCPQP~}s6%b4q zgQITi{C-!4W=aII$`_>*>|PDNkVg~Ct~$3J@{7ur=@{4!+ZZf2>*`hD99=yCT6gjI z1i{!B5$uoOZ@DtJOqsh(SE6-2>p(IOm!M972*qRQ{@l3efZp7QP$xi5)AgXg7w`GmeA7`wS_yF1pjEFzURMB&lW53Lh}_`1LhuVp0qG8JC$L_ONH3)v)ge; zi2k6Gv1qi{nLgr~`$y7hD%imvs~Y6Vq!m9hYwUTOYtrg*^?=yX6Uk3qwlRa5x!7o# zz-=Yt0#V84Qqzc75xmvnNPXGrKh_mNOb~)kw-lx=6qAO#1uMFlbDu2Ff6AV_tkPZ0 zv{Wo|{rtQt@$gYwVk5SZvATiTGi}Y1p>ceo&QTT&Rfy_Z!Q2^4phQMHkjX;qFug~T zU*Sk$?$q zy1f=7esQ)Vs|IJPA@X+IcMTiE+rvV4H~ASlVrxO4T|1x*FGpc6v$&2vw>y)7alEhP zl=cd9cm^~+UO*Sm(}Z4VgiJF!@b|osbYthWV*b;aP#Ru*Olo!wU1q;xFzNU;(&>;C zamBDQCppb=p-)Hy#!UQBPD18ZEJv+V;%m>(t`=iSFU}R^Ht*cBGIP5k2S}seg9%E= zcq!p>fh2tR?UqwzX8YOV*I`N>@V0kY&L0Y5ira(wPu;;CWG8=I^1%HB`1F>UT zTrOX*_>qTC56&GruS3$`vxR4flw~Un_w7@hXC|a3l04&OXH!WkQZ@^x)FCrdN8%Wn zS4aKa;0cs6mtifI*ZC}!sxWG;b_ox* zE^J-$FcC57v=x+E{qluV`0Y5gpshwRE2Q+^rHSo|?MoSU`)@f$$595uLVs1sUCu78 zk9k;QmM)%tcGwMtl+)bzzz)%rXL`RJ98H*uC;XO4zeS~-SLU%_^-I>t@SPcmA2m_C zKybe^FkrU%6@Yr&wlmh5UnfRf(-*X-x6ye~CSLee^~U;#K`>Q-Wuk)!T83p(S6p_LPEZz zRWs4GhPQM-UbLSWOV&0ejyM+GejRq*lnA1Vq*AA5-X!pan1FKB`GS&RB6S&GhHvxo zBh!kRKgrPfV(nwZ@4~Vz%;Y_6RsmGqBgIe z#hMy`?n$$1wu=)BY#zH5QLQwyQP_A?8C`WVFQ)_DiVvw%!&qZ=i4O}6wk-U3T9t;6 zWIC}yJgW?t@q~9t`k0;rdfBVyU@P3P!PC^X7 z!E>?MeLjr4gxlVpV$l-MK;A5$X3OpF?jv}G6h9Ps2>g}*&z*c;fP!F2UQ`AiyQnB6 z@T-g~HI{WBlk2!?Yr@$go=31RQrbY{KLEd(52^O`FMB& znGv~J6)mCHF%SR{6eIUog`2GIC2v>3U*s|?KeJAI^j%Z1o-pvr3_IF>0m!9wVambO zv!02gLi@BU?D7=K>O@{=Xo&mzhthsvu4uSoB!tcqypaH;whZhIn9Xs&M$j{9XdsYG z<8>Nu+Pe+RFKxwQA>Vu@RbW)n&8`)8zayaB6q$UT9X=2>L4Bl0``+DE<>t%ny_kquwZ5vS=!2&V>}H*$^~?i zk{2s_>*XXem#5fcg-keg6iZNDJ04jj;0A$RWJ`^*6!}u+GF6QtS2jw1wsLZEP|4Hs zgzNX|Lnx*17x$sBZ{Pr^w|-qAVEm4Z+2ww-*h@Ugmf`4f40$zPqSQSK@oj8}AFN&g zqc+}G1Et7yjhXdLyk2EQYG_7}El$rn^QAE$cKqXVz_K7Q4KCfjcqe|=y#4xyN(rF& zi@=B9fN?Eq#FqIAGIDvB@-45XTE8J!9v#85*|@yg35rJw7RlHO)1z028oo!9Z%9>G zooOtzQ^+Rht-IW#pdOCX@Z5&eM1wa;a3GgQK|{xul*e~$!*XZ+QWtM#uavc;)APBu zl8R(HL2n_8GluE3N%N2=l%dU+H~S&feB~LdU811tovXiCzDqM*mNnOwRrl>^dHFOA z_wLwFnZ*FH6NJ^tK-b8I;9$TU#VUs>Pd8|)>UZ)lha@1b5y^LS%&scXl3lnu{o2Sg zU|gJlF(D#gf>n%u&K%0WY)*-}uP>Ft$DKr0g2zlq!84N+Y00|>+c(GTgQDAwr`6)* zS>c5(K^Rp{i{P<4e;ilapTF5=@}sNAG$&-4 z%I6kGH3m<5TY3`g%TyvqV_6_}@dXBFwLUKqeH;p- zg%vVQ8#L0;pvmlF88>iVj1GSGBbQ$##VyClTmv|{8doWio^`aWiTNk>=?;IHJvdxT ztJa%BW4-;tmsL?vYtO-RpQAd{nVG?Qeem_ZfTWlzSC5xO4}~tc)ty5EF8T5~_o@I3 z)%t=n2u$k3o`_oN5QNn-=l(cH6j1;(kI|&He(2GL&NYH-#1$C++>Yab>v%oRIUsfv z$*ub`WA}p5kaLR4nNJA!-P~C$M>=2EE%3CGvh(ZWSnW{8(Iq-l@NOW=lF@-yvK)GY9_XiEK zhVG6o+V$8BBhK|F66t7;8;>UV70@e?p~{jD}JToodxo5ORU#JOHAT}PZ)Oga&zS!Zjt>k zYG@T&{paIIx;r$?R((;^7E(uG+c5qX{=jDj-D4XOFiyc!s!bLgbm=#$vDSCxfxKLi z@qu^z8($VQgH%F4`SRF;Xfd`;lPW3LTtN#`VmEQLYOWSMI^p&RkL854D0yV$ZR}6c zPB^yPi?c?N4;2&VW|3)e5P12Crf%v<(EFRKp5#@0Wsx|@prg^cFizLV>7JLrV?#9~ zd()!Y6ZVXW`v!P?+MIBVll5}IO?l=B0-$n@U7Af;`=`vOuMo)@SO$(_aB*5>Ocryx zA|Yx(@qySes`R&;>_vOEjA9-4xQF0mFFU4GtU4fmpsU!;pLuF8Rw7$WWfWTj4IC&WN24x|YTsHgQ~L-{VplP{zB?NxH(O__>^GE&n(?ASwU zg0}5Ll(pwS;-$D_2hw{s5A&bG7G460nyov}X1FC5#ebxlJ+0KUgiwIGzdh*#{OLe{ z;1-WoJcm3U?9_ekNnYfW2^1}RYR|~UGab9b9MHe7hNUWI7VWTHgwH?9bpsPVQmnMA z41r8NiBrUdMtc?b8cXPinb5g_7p4^1t$qS&0TKk+uuj5l>{aS$FYlivZP>qUE`(?0 zN;xK_Z_lN;^WzvhmWfsbB_xFdrFU~%A3+6(9jCV13%i*~LX)9O=IP~^=%IUPim9K! zHmYJln{?IQIiRmN5VMr=DHXPV%zWji165q)ycL;yT)-Ph@ zFDgXo;0pr8j@y$vDjUdNAZaE1e2_}y<-Odl1T_w|-E$BvUPB|&mTBZXLf0qU`_w)B zNob73GLU$N?WW{}OUfMSaO$P~@dNg^C(Zj-d9PaOy`U`{_(0?<4^(Zq^!ykN6dx#d zW=^*!R*P{-2Cj`XTR@iw5*ps>v2dqt&JdU-tPDDe0XuQBvgyR{Ajc&E-zrjR=>9&P(G}KsDZy$Cp=s+LQya^Vt5M(m4K7KBlBP z_^&mI`9Q2~7!hDjqD2?omW$W?rGL%_a=!I?ZuUeZGrHl!@r@V4Hc&@k+g0Ifb}#cj zBSIoi!+h(k$i)sGn?PW_0M1obmVW^|aGv!5y#KL95Zn7RST~8EpIKJ>PJ)ai^90>di#8MwR{I z5*O~xq=8OD!lJC1bR1O}S}JM{ssw<72nG-f?hD#OO7ve{4Q&5TSA)J9*B^<4{~zlQ zY#<}>|A>gwaefVC1Pl?a_L5|+2-cF+I+`cns-4fm)o$)arg_y=s<76T# zgJh*|{g$B0xP9L=ROW6to8u!cPwl+!v^E2z~;- zYgYiyeBa5y)_>hh=zqz1|Mb6ZCT9Q64Zc`_ljHp(<#-i(AIk2_hgU7wof~*h5MA*6 zee>i-_;14f3E8W=!I5HPZNDbxIaQz(c7@tvLLDa(F6BF+sRqFxo|o+lE}WXMkFVeQ zwq`7naU`cd7#$`!5rMJ4ziUG#?PA(yb!p+BWaxJgv*Rv*!~aU89>V#F>?sL@Z~0m2 z4EnkDz3%`YRj<`uw$|siEGR}Az_I4;e{%3q>EUbVhY)bAVWytk3Ay9u2&cX}UZs#| ziImbJ-;y+WV(I{7W*qCvZ&gJP>^RIkr~_#{QthJ*akOv2+h}i=1i89yPzEc$4U%IP^1a0NqjHG#Qo_Y0C{!NdZ-+H7^u+*axG`Gf% zD}t0R(lLwlRYdnu)e=?ewIP3VSy%UTo~L0&80|SPfne%S0I?Gom*yr3u!R@cy;5%T zBqmN79LSd8Zo9UUS5)p)EcJTXhxeQ-U&>dE&h+T$o}NYI@xFjxf88jUsLp3InYr#c zJ2pXNbvU1b^caV+tGdj9p|Y)aF#M_Xl#1RKJ?kkKHr&<+x5&y{4B@%*oNZ(QBQ>PB4 z3aQlmE4P*49ltM$^A%cv*a_D@_tcf;7^q7qmRX>$MUePEAc0<+S$l2=ep(*E?;~P& z)4g=5eyEn5nHpqCeVMScc0e1^qE@saft@%hL1H2^>xkoBYnvgNqx;bOR2Q4(XtkONWqEc{JI8lYCh4quHqi~a9L+U$yc7~~bJ0|e=D%DD8|yk2 zzS?@7|G{-qs=llyOVLA$%R@H&TZfXnH+lTTk7=%(E^;_OHi*S*%kNN>)t8k(?8w?= z`!sFc9zwbwyf>IG5IKmNhL_X?a#`G<{iaE(`31^){e`&62{7bR`IgG%l>+ugC8xhN zo+dHHB{@4HEclpd@PBKS$BJb!ZwU#g5*FRqVvH>Lh^2q(Eq4*^AMNhgmfVKW!{Xj* z;X#h;5ErQ4rNc@~Lf;0_2$uU0zd}@aF^%hyC4rd-MJdVG72t83V6?#1OZD}mLiZ)a z&bI2y>g?yvtaI$=AN55}KWp)^YywD_M^;gQ*irDysvDK~}L0r=*6Z z%1CWKyp?XBIZ*T1Hfrm2S4l7;BZXV3hM1()8oy*X>D7HOB0C*yx3dO}qw?@p1Qc5i z9&~+)3bN*7y_3{+txjw!CuBw=qOo(8-eFJABF%4U%3-{`oa7 z#BCY3$&di9HXS|+ux3#TkN?1LN+KE*7I}7eV^8;60-^wGwv@Gb&%BFvvRL9GNhV?? zM&B7tc6Jo{ofA`2i>0+>0PTP+l8-g6r^7 zWxIH0kCex1^`>qkL41GCj327N{NQLODuUhV2(Q9jAIky2%Cs#A(bqTT`1ZM{)t_R;<-~=* zKP5q8`%|u+sclevvDZLnD0?N`lF(>_EA0*Y{I3-x6oGk}Jx$w(O+W9lXZESrwxt{r~iTL^>gPiK~2;UP+3rirFB3YgS4 z;$yq=u>0M7=(O?57PH0ORco~j+((_yuh|-Jn!&6N3aWxO_eD9`zmXoK^&pP}=QM3| z9xMd5e>a2~dFedI@UlH<3BLQ5Sgrqsx%$_5{}=vr8oZp0in~oGm45_&JLl_a3m7zW=I{$zv#Vx zf7fRJw{9l%O``tV9lUoqalQ8jZU2N-|nF%Cdi$3J<@<^RlMARLiyaDZp~fjw0B z1UxmEn?K{bel=?pC7O|FerZXjP^&4IlSrXUQ3>jAYm6Rygz*~NW7%v&L`xFWH-@)d zf7()yB8P|XFxe_83K1JjbKVVx`iFXBr8p-S)mg-)E(1sSVBq&ECNEPr8jESU1ht|`*WK6&-$GRo z`&FUNA+r+2e#5G%fzEV1%|2)-a&muii&^rqvz0w+U2E z+#A1k4g>rwRS$@L7sd-sq2m$%$+WTlh}7AyostO{p0ODRFY=xgN!XxALb6q{Df|YD zhOaljkKPtMLVt^>f@m@{N|9CjCC!TzM4c(BViPqWC`<=cCO!2uIX7}9q(}s&=7q9R zL2TM}8t~{%H{dQ*CdGqNECGL2Dc?k!g^vD7lS7F}oe51-?4( zz9n3VPpl`I+$PZIyAs6Kjb{_#XM0fY3KY{1913Jc4u z;j76-yFHPD$z_!bKi^BUH%>2MQ&tEOUL*+C2V1gdfPHpmN0t2UV61c|I?VO5R>Gnw z;l0MW7OplLfrzhw1ghIay#rXAOQ+4AjhybghVI7Y&b}jqH^o$7ARf0lCchq7PQbbt z-AhT!>>iPFF$xML8Y2G~zZ#+PrKZi_T7WbS!~#tQh#gP9biCSa2ZfG7f~Q8hMI@&u zXm1JgcPQ2o(v~7t2b8S;*i`nYSeu&iZjtG+klhiAI3}0-hhR@n$Qb<(ScI!_mjf1J z`X_nCc-4mbSy}j}U>^6)m=2SwJ2zn`j*5ppY9O+t<`t1Qz6H*FOx>ym+TH4fd^pgM zxi7Cjj)_4Y{bU-pey3`<{9<@0y8)rsb6NATf-G2!NqW#6J!@-_D!{#Qs5}f~I?sbJ?u6`Ybqc*Su2IB(uBem-+QPSo{r-GWklhl)7X- zoK}x}nI=YcWupK!p7pm&MkZ-#x?#wdvKI8Q59HF6PvL}bN6We!iovj9%NJ=X^gSTS zh)EW7_T%llE2RXuU6V6wMYJkNyVlIVz);CMpw!$%o#*OyjMGIWlo$>mlD1FF5G_3i z7)aPKIzlKHk*1*3Vlwv5({I&eK08p!z(EEP=$d~0vEk#5quWBl3pN%C#QvW$SHGcI zCsrRW*P7%v=kd1ny=?>e49CBnS)}i>{YT}<`5#_MSv-!6yPKzrp=vc3J9|kI5m8C9 zQcgnJZaPaO=EwCzn-l_mk_Rl*9WALyt*<|kA4E6@IOF-V^Hs~bvz!PgYuI!F2M|+M zXXyU^px{{Y9Md4aAojih1pz>dJiwP8^qVcPdrF9t;eV4y0taso!2ciGOeotQCZ_v- zH4$ox3v_r&qacfr5hpBpK0UtN|BSK-E44q`!|l*qV@Td-f&?oX z_IMu+{NdO#t{5Np&&o=ireD%0{eN{E+@qy<$3&_P7Tq z$;N@iR1O?C;10k9^OjT?BlFVwsN5JCms5lE30d@gVIiBH4R?`mw+RlqIF2*K|C)jQ z$#)>@3ktIY@OdZHZnVpuKM~HGej>DN)@ECS{x+rwRi%Cd`-@nWUw^=2ZPH5AVZQk# zSgu4Y)!5CO-qj78XplcXe{ULd(TdMf{r2}Ke&u?iHCFN8^06fQ1q&7v&{Vs6G2)v` zTLJ@f9>)LmWpQ1Z06tm!3J7OxHGf5*3W7g@>9QwON5?&QNsD->U6ckn8wb;`YI-4O_0kd*QGM76H4fBR9Ma6& zzASSDh4M#Toy3^u&>v*;U&zR^J=cgp5vyCEqmJ7#1)0CY%IhP_eicAy|)M* zr7j&~hcD+OX;3?-w&L~GHz@hLM0kj`vA1qP*geaqZ|alBUcCw{ zuwjtuR(-2+WT(Brc57arQOvzsAa)eIs4eHVWoT6l-IjX2qaehKwNxGMYRO$A3g?f6 zUF<4HXp9P-di3~UpMLen?@djNB2Hg`5UD85GAVsJq^1r8@L=g(NO7dYX~=B2%+5n% zTk55o1eQ<|_I6f^9mI2ZVZT(Yy8;xhDRhI@@MBpwv)Wc+%_Pu%Q;dtNypZjLw`8G3 z@aNM!C@22PcA^QC#QNbKy(b&xP1f|8PnP&8#I}`~ezAKqlav7M63T~Pie~3_pl;d- zh#l3~LpCg}YFm}Q>7(;{TQOFR)b+w-Lat`x#HKq6g(M@%YNwY+hS*&w0PLD2cCCW3 znOkKMCy#!MW#zc`&4fI_MxZ0)Zw1|5JwoVPNmooskR0MVn-t`=rVySU@W^wkP3~h@#~Nr zM&9Xfiht|fDJ`9z{je4lhct&+SPu+nWL){CHEd1=7S6F#T%!H19HNs&$jd@-nr)EX zfsf#fQ-~ZVQIH^|;N>X#0^`26nn=SntCV$Z8l#ygtq|m=Z%Dr5p5E;1$Ofk?R~UHH z;949nj;?+#*BT4HXI^QHJO9-X^9*v$G)epPv$jXtQ@AqU;{%(OrTzF*$q$O*7M!!? zb2KbM@|qV3>pUQK^jD^GJp7+)xbz<^;KHM&lJED}lXgbPoSOvXL{7Vk05D!Agc0Ud zFx~sV$LBzznc%;%AeJXQWNAQ_C?2eEWKB-HfSqO$I&=Y3c=QdX?crR_LMXyUQ*#nu z74y*`n#SZ*@+1%9tdCD4aWKsD!-Z+AuTKLfxuHY9>R^d_j&Rf9+)lQPH)ZagVC{QU zNztoAEFGzIWpB%jL2oqL{&09@7~}tKbwG9@=9C}-D8=^;j*gIof6wT`Xk$>k)mrA- z3m)py_QuQ@NB7m1-voIna!XW4%5fqr_fzaoZ(-P_>E`11ClsU`Z6ug)on%pG{>Xf7 zn$^Y!(+)RD*8bg#jxDCdH2Mo1lsKTir?}xWtPpll`t>sGJSGeXK(h76F~n3*N>zNB zhu5OC9a~L+*{j9YrqxiC$Wk{w0++m3iZ z>|-P0^d;4A5)JjqpJhJTmISGUsROaIyZvv@rhh@#_+R`JRgGC!@ybc4D#KtoQ%3_9Tdo35a&tL3 zS!XUlN#h?MsaNA}`xc9C2MJXUt~cZN7K>6^!y-i%-@&aCEe^@V^kj*|deFdo0I9L4 z02qHmUsO;5U@n9p*5BvpxAVWvQ|7r)_qn{a{JGRM`L2kwVPMe%pv5{~1# zbi)VHJ2%=ofY9&y@h^gMV4n<9;P~IpW!Tslm`(^MX<^6Mu$oBQuFU7}lLVrmH|VB4 zv)!*in=&UL22V&wH+i?2bTazK_^3Y0$zyg=%b3%BwJe&%ICfG1Rl8sDJ^VmTrWGL> zO)xe9zAcv?;p>Ptu$7THy z{6$y9xd6*z8m2@(cGu6*7|>=C)to`>B)+yl?6`MTT61BXtZA%Sj<`uFFjRt4DF$9`{PkAFFdno#STI zsx%*z7@zxR_HEhd_onffY9q!|wQIjka7&8Men+&P4cI@#&vW<>`4KZ1Y%AM)z>h4? zKr5~6elafsvEzM2`$^5lw$jZdrLfT{NV+~*ZCgvMdwj{(_g+h!V~eU)9Vnk(9wyQ`IgpMqsq(e25W zSxffKF9P_iOqslJ9Yp(}#Uvl5^{mlki`o#pl#^+7ePTbW>|%vDQ0^o4msUBmX0UBQ z%EJjTL^VW<@qH;cjDOX5Jsv%L0w0Oak7P)l5RzM$IilOa%1M9srGD7^{UY?kmBe=_ zwnp6ZRH@5kiMt%;8n@4gm^qKANpmR1S9ia=wpywFZMjYQ`ej+;E&A55K3T(wzKHtL zVX4nPp})nMJMXp`n+R%3Z)Mq2Oa-h^XM(v#u>QM(VBfJV7K^Z?7p2i5_#!3#_!E2h ztSw)BLu7~YYu?*y_9xuo7D(9YHmXK_6+^8e4w7yAG>8=A>Q6J>b9WSI!oQ`2V?|bS z+k*2&6QmTwhcu!l6on0vKh*62vExsU+EsRg2*;c8TaYFUXh#b*S_iY~U>>jvIeVU6 zA-KrDWpa8IIh9+(k(ogGVGh(?_ua^x_kSDC;jl-%$AzsiGD@x}9%JPD{7FTe&a$C6 zk$BGf#p58h6J$8*Gp|c+<)ak%${0 zb^ZG~g`hTzNU}Rr z&Y0h_S00i&g^6?8%ZtBSkOGjQ>A}k9pQ4Wp`GIql```5Gm8|`F(SCad;ruJk@J}~l z*V7CCu$G;BiVHoxBnio9p=0eR@07wBxE%bt8>+HvAV+>hK?$n?R|Opqpan4l(1IYN0m$G0p<2M*fe_EX-sz~{%J7E} z`25`l5h_7yknJP&Y!RiC0xYPe-z}U^tW%jlw6a>m;&~3)I7xa121U6pby)oKXyQ2A z$z~%rg60D|BaI={+*NAp?0%3Lgl9>d3&H~J`vi3! zen&?gNMR9AwmXhNhy`Jvg2fD3ogzImtZ->BtCBUpx(6xP3oBIS^2O>=ypO|HjDh?< za8^xOL#s5?pNRLvMzuv=W%i+9wg;rR9rJTD!P}7mKgSOj#BPcsxP}`wAzTNMu)8MV1E^tUeC%1;jeUvnb0Zm$uw_+Y z=cG7^CyHSC_Hw1zpY227-?LOs<1P1yFttfYl^i;w=$HEBZr$Tj!$@vUcA51(cVP@^ z{5&-!ailAB5rxj2Vt8UMgX?>8=T^7$m+1gs<@8 zn9xJCjWCrkzlx{J2V^2MjMTa`P!A0+b_21a6<}%VcC2e{X?_PCGCLQg^;tl&#dj#m zZR|QHOJ>eKx4_lq@m1;##H)G**HTYuzTRBT zF%#(^DiAyRys|7MT}j*G?~NA=vjfba6Pl;iLF22&tia??ocyk)Vr;AS6tk(Ch*p{` zArtaV=2kIIQHfk{c;5xn&{&+hs+wZB)##)&E28ICUS$U$>i8i(-N$S3 z3qnXld`616;myk$%TrQeD_%o`iz}`Ds8Amn{-ha5R3w(@1;ma43%@;=mOwshW%ES; zTCHVIne@e*UAU_B#Cvpbq(P5BF+aTQ>ql&>Mz7;}_AjFojm%JuCoEiwAWlnJE*?!` zQT6GV-taLJ5WUrz*Xc z1md$bvBdc2mS05Ss>W=Z1i0pAz$A-9~O$S>E|uTnH0rI?2dHISPQIkl13A z9v*DGx6V(ysSGM*=*NpdsCZ~Dikm?F>jWUM+>J7Xe0Z) zO;kd^)Nz1Ycn-cOb#VNc6#IEH@|L@3pZM z>qDFaff~~%KaLTC|DA;g06UFI^e(lEaCavG=d3~@a>gV^!z1z z*P1(Uu$q0S(Ek1my~GjixUcrypveaz$Kc@j zJ3~ZKvXcoFEQQkcuVYqyw*Yp_y=FKhI0_fT%us$e-Xj9ULZ;GgTlSrG)Jw0+AK5>L zu$@L$z{Im@QIZ*!T`VqWf2>%np#o@4k8~OMfY>>!|Nq9t{udPOuP?tM5c;bA1bfeg z_(b{N#r|h$5cZFy!DzrclR@VH!(=2V-!COd|3obX`ZF52Zl1n!|5WQclZptlQYo7w z3o8qV8JoG5eARjTgjRa&o?WCJt^QAcWL{{aIdE}6g8NOiQl2E#&pZ$cJ5PXtR}Vpg z7r2^3ApNpIenu`Gr08z}_qWr_fc>fJ9wzBjW7klTB z+UM6(!x@Wh=6hpW$&%FCM2maN2d5rNo4QcXA>(e*S=>4o)*XNOQkf32mny3@4ziIx z{RV0_#;uaP4$|3mR)%wuRN%d=@i2i!C?e!Aene=f05T9pG#KB|cMpmX-@oUdIi~sp zpYXpTJKrlziKB43p6-Af8(@WL{LXF|SyDx%VH`ceTC*4EK0jF$+V#@ke5p~6c-oLF zwW4r81f!|~5VBk1RtykF!`2K(f1%LT8a$vvkHg6rhLJ(|0!1s(9uyEFP`w%vZ~>q% zRfzxJ^#eb8y`x9md_Q^yHkbl;PNL|@V%7LpSDPn`ElXJCt@e9kQDkKW9p$4?)zv3D zP?LQ1z#7w;nMaPp&4m};KOdH_#oLa@{M#PYuAASZ&bxxH=_7~=*-s%zv~cjnlqoT9)WwlFqe;m1C2q2 zAHOGzJXk*1Sv+FiVg~Q;??2G&@iVt3jaL~t(Cl&E+1PB{X`kH@oa9XY^p1bJ3x2uV zu+h^hJcI`kItii%afRq;{?O2>0Doj?BG@w64FFscz!wAn0icHHl`nzw>j7eC{@1@( z4QSl{Aouz6A1;9j|Npdh?eS2jZT~mFW-@ee2=$;EV+b*^aw;+jJChPptR06EVw9K% zC5NHIGmgt_OOZp;8mvRCGFpdiDH1keYS%7FJ290C2@TKv`%TpIyu0sb-{$?85C8b% zp8Ip%*Y&->*L8otKwx+K*Go$}V`($O6yu0c`y_f&Dfb*lxX&kVNx zvEXFRdm1(O#2*%jBaGoDid^eM!Y3{&euocc{s1epeT4@(q=cOS% zhz%5ImJ?R3LSx2Ag8r({)^>F9UgA`#i)!z$c<8xtW*$}EN5pm8HW}A)_I=0Tk3>38 z2mkNF`wxO1uDKSZQSAqmzug=RD-)aTH53eQDkpA)?_ac`Kvhlh5L+4oaJY$x_ziE~ z{CD&FLUBO;qPadA&GkOJ)}!IxC^ip3GUZt?ygxO&ZSFYY9H1X+ldjz1B!8*n*YK8W zb4zAU?LYoMwT%S>^+4Tt_WIc6nAz;H(CincnRVGORQWRWe4S%-&rveW3V=bZgBSk! zP;I_8y6?u4pH(^&U3}h0d6KyN;YU`_ZKShRx;9nMqN<)uFKLX*{io?Vi{mY~7TVg0 z#6)6mv7)Uac+GeE3&$O<`De@asnl#*(#iGaGJEmxXuM1u8!C3hQRHwC8S|B~|J;+FJmbzIOg`y~j`5uUEk1F-7ALUqT*BQ81S-w&G{nUf zLY3H291C|7%3qD{yXmKTPx(Zvq6-JHg0wtk8-bu0LZd9Ky4SuF9e z&|!mgvxAXz3sJlCU|WW?zABEj3-;E6+-x9uDlWdc38_tH64h0olq2XDSTEL)+=5I) z$fcdF@OV2mFeyx7qMj8Brs7brl>a2X^>3F1*O2fV4sSv8l87xT&a z5e@eF#XJeeYXW}BZ~wgiz}>!@2r`Y7uEnh(dC-6$hw^ogcdN&hzx{*W-+zC6QHH#; zSg>C-(i1)VV&I2?hO?r_(Szo{G56{GaOG)!{Y{K>Qh%*uEp8{!A0L#%Loh4f1q&hj zzC}Vz;8U)IE`H!6j}pz4l_v*YiLvC9HWKX+n@cbK`SH`4ZOLV0F9q>omV5U0wD+_x zlqNvzfgkW29M-dCj>g6+K#-ifU1k)!(TPh@Dt0V};xWLd3`fbwIC2&9fy22YvhQ0z zIo=xr7UKPb^g9Q8Nd7{XRiP;CR>hhAnl_bEPQk7O&HHg(zq~2B)2Pv?acy9A%d4m_ z8}#`LZ9cR(Wlh$!e@XuXphy*g23@duQs{70;R2#LiY;8V>ijMa8wY$KK6Z*1p4o0ezOAt(FXSh&EMKc91@$y*<4b;;v_(lL(#7{udI)p zyjQ;H3IpV4t_1}>cvz(m-Z)j=YCib=5uZcUYZ~&Zdin>6Bx~F6fUFy~g~e9J81yMC zgW^iUqG#1oB0Mu7i|)M@>T^fc5s#4HN*(8S&U=KFFPlOWAFfCPW!kGYeg;{d<+@QA~i?yWRuzLS}%NmNax zg;2=6)IdM}E@_x9$ z8cE6NAIu$KV(g8S(e&o0+vvQ|q;rc|(zbLj>KXv9f5yh!@qy~a(0--6XKa)R<@xc~ zS#r8c`50$_2Uu{v3sg&nub-B)he$NP>zcQEXRwB!-Vq6RXZN8*ro)^W19 zv|;A7$had)mLlaMGM}FQT>y^d`_ESv9pD{e?ukc;K(NqQs4{tX4_#nd`o(8^-L(2R z#6#(;u&t+AuuW?MM1{2A0|sn72Eo9F5?}&ff)~1UFL8cE#R*6$sZqi2#R=LuLv-7$ zHfkUFR-=9QMABUDtlH-#z`?2HXi4BAn$gbh0maD^7&xV5o7m~6r)1-sA3RiUDbP4v z=35|dE2mdwsK9BQiY+o^QeI=y$(l$Yx*E|!;93bV!%dLk{MZ?DK<@OZpTn)M*YQRZi0 zs2OrhQ5T1CB%t_RqIh@uVjP+(p{otwE069pzE_^&$G599&h}X1v6N5AZwKWmvd<)PC~|16LGz@((QR*y04Zw? zytFdLkgy9Z93M|X`5CQBgr6~yXx~HT7xsN|s1_`{%VT^@I3=Vrl6u>3aE5tAmkZ9B z=~8?40D|N0BEd15dg=p|RP}3FY9c(?}W$0;zCjwBft1?BY2b^rcd z8@*xw3%z0c7R;jSo?pc6h=EWuNxh^xuX|qQvFjCpB8g9WyF>cZ%YJ>p6m8x6#4CLS zFT4&=q?htoQrLf#rY?)j+=F4lZ2DxD01zAwG~va`n%3Rr&S?zn5cW)=R@PpO0l4&0 zp>%I3k+KZ-M(XMoiSA9l)qBvdu>L;?;Z_Yh*W@|Sk`H|A(H0U)sv6yupbj48%y_1I z-5$_jPkOlS>)qYEdof4aqV9s=ZG1uE(vEZ!o0Q9Ia!i7*-Xv-qY)MZfTs<@d_d!HA z*c-$<&@n88h-i-7`Y9Z??@y>tGQwehV1Nk;u!7t@kFhrux3l?b#-YPCt+jy_IvZ4f zs5QTF^ue`(rdT=V(IdUR|83obgu2Ceg5Y8>xHg^4elZX(n&R!Al2N=Ax!QBec_^u0 z+jEeUAM9)^9b&iGpA;3kl-=K5CLI3*sFlM?^akkidAVH4$H*J=Pe@2igk2 z*s+|fS)p>PgjCs{xv6!X@9Psk50L+a;Q+y|@1AN-T}hJL*L!^3Q<%+;SC87BwD-KC zVj$GRRfGqPAs2WM&Zj70sN%Y6ssH!meSuUuEe`o%u_I+3iXRc8fUQnoQy=@MP6LWV z=;2wLb%V#?4A<4^?%REYFg7L<8ki4|Ww*~w$IM5>`ajQmIO~@Y^Ke#FZGX4><%tA- z-w`Iw%veY>XPoC_$kiO{01{=V_u3t9S`=&>h6YhF3O}kJ(~zrufA^4#fA^hO^!!5W zk^(k^L`YHX5b;p_4w8F{3&&d5=0@A4iSZdm8n5%^$^?M`;W;|PnbkQLp9%c$J$l*q zmci(o+q>;6QmjtG#0H%<(^MVK#jmqH*RYalBzBPAGN2s@Q(0~pxk_nlH>7}%LvZA$ zdt~@yQL8Umu*c5^Y)M3U-!0WbW>~7T#{N|8qauaIc7ONe6=!i z%a$$Lqu(xeZ4gz97DcD(LtkoKtv=Y1k-)H3F!|oi2_YoqlbzgutZKp+z`iWNZQ$bx z7&$liAcWvZ1IaiJeHV#ZtXW1%{2^UB=5y2bYY4+J zg)kiL*;z3Gi%GKA0!+|2Tpk;+69FW-BW7k(!^G;}d3%oh6h&5TT`r^Toa$`|;anh= z4CDyTD&`nnMvUJ-{jBxi|H?18sgRR^9m#myRXCkWAcm zM@2xT#GrJNJYhzud3h$Fu$*^IY4C0EbZOxzh=8gh34h>MF=hVHw7|(id(X zbXz#9lHhlLJ1cbgULTSqiIDse1I!~;({zp}X?+)MdUOWY@Q$ zzr!pt!GMnhOz09epJg5oT+zR|pfOI>FOje^*!65s#eg(&nCwm-&$zI3t&aB#kOh`r%d|(QO!i8#WlyK--HJ0$K`iW(K z=FzQ3*!W#U%QB}=vms%m#*>&dT-17~#=3>w4II93{bKu+BEFqa^| zbH&dnV;2Yx!~~Rcwn%IOT5r$OYzrXL_7~RmJ@?7J_B<(PZb$Tv=sz3n+_R-9XK&Y* z>ti>fN5W_C+203_IsNr_JQ^lsf@N?m+MBG020><*TR{K~Czw@>{r} zaUasUS$hhfbY;?k$)sG^p zOLN;oQX2PeJKtC|vGJA8NR7;^> zIn#t-f~}_iCmi{qQHfrnB2h%?-zpvo_5$m_FxURLyf#C6si}f}r-G}xYEB#wbY9|F zYg9LBFfSXAD+q9!YM6j=pVz;nKvNBP2wEq5YVb7${L_!auTKyl%=}2~6AC0dZ!h8( eu%IP#t_2g05EOf7!ZQ(!ZO%_LhEBLaQvU||C_rZb literal 0 HcmV?d00001 -- 2.7.4