static GstElement *
setup_vp8dec (const gchar * src_caps_str)
{
GstElement *bin;
GstElement *vp8enc, *vp8dec;
GstCaps *srccaps = NULL;
GstBus *bus;
GstPad *ghostpad, *targetpad;
if (src_caps_str) {
srccaps = gst_caps_from_string (src_caps_str);
fail_unless (srccaps != NULL);
}
bin = gst_bin_new ("bin");
vp8enc = gst_check_setup_element ("vp8enc");
fail_unless (vp8enc != NULL);
vp8dec = gst_check_setup_element ("vp8dec");
fail_unless (vp8dec != NULL);
g_object_set (vp8enc, "name", "encoder", NULL);
g_object_set (vp8dec, "name", "decoder", NULL);
gst_bin_add_many (GST_BIN (bin), vp8enc, vp8dec, NULL);
fail_unless (gst_element_link_pads (vp8enc, "src", vp8dec, "sink"));
targetpad = gst_element_get_static_pad (vp8enc, "sink");
fail_unless (targetpad != NULL);
ghostpad = gst_ghost_pad_new ("sink", targetpad);
fail_unless (ghostpad != NULL);
gst_element_add_pad (bin, ghostpad);
gst_object_unref (targetpad);
targetpad = gst_element_get_static_pad (vp8dec, "src");
fail_unless (targetpad != NULL);
ghostpad = gst_ghost_pad_new ("src", targetpad);
fail_unless (ghostpad != NULL);
gst_element_add_pad (bin, ghostpad);
gst_object_unref (targetpad);
srcpad = gst_check_setup_src_pad (bin, &srctemplate);
sinkpad = gst_check_setup_sink_pad (bin, &sinktemplate);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
gst_check_setup_events (srcpad, bin, srccaps, GST_FORMAT_TIME);
bus = gst_bus_new ();
gst_element_set_bus (bin, bus);
fail_unless (gst_element_set_state (bin,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
if (srccaps)
gst_caps_unref (srccaps);
buffers = NULL;
return bin;
}
static GstElement *
setup_element (const gchar * desc)
{
GstElement *element;
if (strcmp (desc, GOP_SPLIT) == 0) {
element = gst_check_setup_element ("mpegvideoparse");
g_object_set (G_OBJECT (element), "gop-split", TRUE, NULL);
} else {
element = gst_check_setup_element ("mpegvideoparse");
}
return element;
}
void test_shutdown()
{
GstElement *pipeline, *src, *cf1, *ar, *cf2, *sink;
GstCaps *caps;
guint i;
xmlfile = "test_shutdown";
std_log(LOG_FILENAME_LINE, "Test Started test_shutdown");
/* create pipeline, force audioresample to actually resample */
pipeline = gst_pipeline_new (NULL);
src = gst_check_setup_element ("audiotestsrc");
cf1 = gst_check_setup_element ("capsfilter");
ar = gst_check_setup_element ("audioresample");
cf2 = gst_check_setup_element ("capsfilter");
g_object_set (cf2, "name", "capsfilter2", NULL);
sink = gst_check_setup_element ("fakesink");
caps =
gst_caps_new_simple ("audio/x-raw-int", "rate", G_TYPE_INT, 11025, NULL);
g_object_set (cf1, "caps", caps, NULL);
gst_caps_unref (caps);
caps =
gst_caps_new_simple ("audio/x-raw-int", "rate", G_TYPE_INT, 48000, NULL);
g_object_set (cf2, "caps", caps, NULL);
gst_caps_unref (caps);
/* don't want to sync against the clock, the more throughput the better */
g_object_set (src, "is-live", FALSE, NULL);
g_object_set (sink, "sync", FALSE, NULL);
gst_bin_add_many (GST_BIN (pipeline), src, cf1, ar, cf2, sink, NULL);
fail_if (!gst_element_link_many (src, cf1, ar, cf2, sink, NULL));
/* now, wait until pipeline is running and then shut it down again; repeat */
for (i = 0; i < 20; ++i) {
gst_element_set_state (pipeline, GST_STATE_PAUSED);
gst_element_get_state (pipeline, NULL, NULL, -1);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_usleep (100);
gst_element_set_state (pipeline, GST_STATE_NULL);
}
gst_object_unref (pipeline);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static void
udpsink_test (gboolean use_buffer_lists)
{
GstSegment segment;
GstElement *udpsink;
GstPad *srcpad;
GstBufferList *list;
guint data_size;
list = create_buffer_list (&data_size);
udpsink = gst_check_setup_element ("udpsink");
if (use_buffer_lists)
set_render_list_function (udpsink);
srcpad = gst_check_setup_src_pad_by_name (udpsink, &srctemplate, "sink");
gst_element_set_state (udpsink, GST_STATE_PLAYING);
gst_pad_set_active (srcpad, TRUE);
gst_pad_push_event (srcpad, gst_event_new_stream_start ("hey there!"));
gst_segment_init (&segment, GST_FORMAT_TIME);
gst_pad_push_event (srcpad, gst_event_new_segment (&segment));
fail_unless_equals_int (gst_pad_push_list (srcpad, list), GST_FLOW_OK);
gst_check_teardown_pad_by_name (udpsink, "sink");
gst_check_teardown_element (udpsink);
if (use_buffer_lists)
fail_unless_equals_int (data_size, render_list_bytes_received);
}
/* Create output-selector with given number of src pads and switch
given number of input buffers to each src pad.
*/
static void
run_output_selector_buffer_count (gint num_output_pads,
gint num_buffers_per_output)
{
/* setup input_pad ! selector ! output_pads */
gint i = 0;
GList *output_pads = NULL, *input_pads = NULL;
GstElement *sel = gst_check_setup_element ("output-selector");
GstPad *input_pad = gst_check_setup_src_pad (sel, &srctemplate);
input_pads = g_list_append (input_pads, input_pad);
gst_pad_set_active (input_pad, TRUE);
for (i = 0; i < num_output_pads; i++) {
output_pads = g_list_append (output_pads, setup_output_pad (sel, NULL));
}
/* run the test */
fail_unless (gst_element_set_state (sel,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
push_newsegment_events (input_pads);
push_switched_buffers (input_pads, sel, output_pads, num_buffers_per_output);
count_output_buffers (output_pads, num_buffers_per_output);
fail_unless (gst_element_set_state (sel,
GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
/* cleanup input_pad, selector and output_pads */
gst_pad_set_active (input_pad, FALSE);
gst_check_teardown_src_pad (sel);
g_list_foreach (output_pads, (GFunc) cleanup_pad, sel);
g_list_free (output_pads);
g_list_free (input_pads);
gst_check_teardown_element (sel);
}
static void
setup_cmmlenc (void)
{
guint64 granulerate_n, granulerate_d;
GST_DEBUG ("setup_cmmlenc");
cmmlenc = gst_check_setup_element ("cmmlenc");
srcpad = gst_check_setup_src_pad (cmmlenc, &srctemplate, NULL);
sinkpad = gst_check_setup_sink_pad (cmmlenc, &sinktemplate, NULL);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
bus = gst_bus_new ();
gst_element_set_bus (cmmlenc, bus);
fail_unless (gst_element_set_state (cmmlenc,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
g_object_get (cmmlenc, "granule-rate-numerator", &granulerate_n,
"granule-rate-denominator", &granulerate_d,
"granule-shift", &granuleshift, NULL);
granulerate = GST_SECOND * granulerate_d / granulerate_n;
}
static GstElement *
setup_element (const gchar * factory, GstStaticPadTemplate * sink_template,
GstCaps * sink_caps, GstStaticPadTemplate * src_template,
GstCaps * src_caps)
{
GstElement *element;
GstBus *bus;
gchar *caps_str = NULL;
element = gst_check_setup_element (factory);
srcpad = gst_check_setup_src_pad (element, src_template);
if (sink_caps) {
caps_str = gst_caps_to_string (sink_caps);
sink_template->static_caps.string = caps_str;
}
sinkpad = gst_check_setup_sink_pad (element, sink_template);
gst_pad_set_active (srcpad, TRUE);
gst_check_setup_events (srcpad, element, src_caps, GST_FORMAT_BYTES);
gst_pad_set_active (sinkpad, TRUE);
bus = gst_bus_new ();
gst_element_set_bus (element, bus);
fail_unless (gst_element_set_state (element,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
ts_counter = offset_counter = buffer_counter = 0;
buffers = NULL;
g_free (caps_str);
return element;
}
static void
setup_input_selector_with_2_streams (gint active_stream)
{
eos_received = FALSE;
g_mutex_init (&eos_probe_lock);
g_cond_init (&eos_probe_cond);
selector = gst_check_setup_element ("input-selector");
output_pad = gst_check_setup_sink_pad (selector, &sinktemplate);
gst_pad_set_active (output_pad, TRUE);
stream1_pad = setup_input_pad (selector);
stream2_pad = setup_input_pad (selector);
if (active_stream == 1) {
g_object_set (selector, "active-pad", GST_PAD_PEER (stream1_pad), NULL);
} else {
g_object_set (selector, "active-pad", GST_PAD_PEER (stream2_pad), NULL);
}
eos_probe =
gst_pad_add_probe (output_pad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM,
eos_pushed_probe, NULL, NULL);
fail_unless (gst_element_set_state (selector,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
gst_check_setup_events_with_stream_id (stream1_pad, selector, NULL,
GST_FORMAT_TIME, "stream-1-id");
gst_check_setup_events_with_stream_id (stream2_pad, selector, NULL,
GST_FORMAT_TIME, "stream-2-id");
}
static GstElement *
setup_mpeg1layer3dec (void)
{
GstElement *mpg123audiodec;
GstSegment seg;
GstCaps *caps;
GST_DEBUG ("setup_mpeg1layer3dec");
mpg123audiodec = gst_check_setup_element ("mpg123audiodec");
mysrcpad = gst_check_setup_src_pad (mpg123audiodec, &layer3_srctemplate);
mysinkpad = gst_check_setup_sink_pad (mpg123audiodec, &sinktemplate);
gst_pad_set_active (mysrcpad, TRUE);
gst_pad_set_active (mysinkpad, TRUE);
gst_segment_init (&seg, GST_FORMAT_TIME);
gst_pad_push_event (mysrcpad, gst_event_new_segment (&seg));
/* This is necessary to trigger a set_format call in the decoder;
* fixed caps don't trigger it */
caps = gst_caps_new_simple ("audio/mpeg",
"mpegversion", G_TYPE_INT, 1,
"layer", G_TYPE_INT, 3,
"rate", G_TYPE_INT, 44100,
"channels", G_TYPE_INT, 1, "parsed", G_TYPE_BOOLEAN, TRUE, NULL);
gst_pad_set_caps (mysrcpad, caps);
gst_caps_unref (caps);
return mpg123audiodec;
}
static GstElement *
setup_amrnbenc (void)
{
GstElement *amrnbenc;
GstCaps *caps;
GstBus *bus;
GST_DEBUG ("setup_amrnbenc");
amrnbenc = gst_check_setup_element ("amrnbenc");
srcpad = gst_check_setup_src_pad (amrnbenc, &srctemplate);
sinkpad = gst_check_setup_sink_pad (amrnbenc, &sinktemplate);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
bus = gst_bus_new ();
gst_element_set_bus (amrnbenc, bus);
fail_unless (gst_element_set_state (amrnbenc,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
caps = gst_caps_from_string (SRC_CAPS);
gst_check_setup_events (srcpad, amrnbenc, caps, GST_FORMAT_TIME);
gst_caps_unref (caps);
buffers = NULL;
return amrnbenc;
}
static GstElement *
setup_element (const gchar * factory, GstStaticPadTemplate * sink_template,
GstCaps * sink_caps, GstStaticPadTemplate * src_template,
GstCaps * src_caps)
{
GstElement *element;
GstBus *bus;
element = gst_check_setup_element (factory);
srcpad = gst_check_setup_src_pad (element, src_template, src_caps);
sinkpad = gst_check_setup_sink_pad (element, sink_template, sink_caps);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
bus = gst_bus_new ();
gst_element_set_bus (element, bus);
fail_unless (gst_element_set_state (element,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
ts_counter = offset_counter = buffer_counter = 0;
buffers = NULL;
return element;
}
static GstElement *
setup_aacparse (const gchar * src_caps_str)
{
GstElement *aacparse;
GstCaps *srccaps = NULL;
GstBus *bus;
if (src_caps_str) {
srccaps = gst_caps_from_string (src_caps_str);
fail_unless (srccaps != NULL);
}
aacparse = gst_check_setup_element ("aacparse");
srcpad = gst_check_setup_src_pad (aacparse, &srctemplate, srccaps);
sinkpad = gst_check_setup_sink_pad (aacparse, &sinktemplate, NULL);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
bus = gst_bus_new ();
gst_element_set_bus (aacparse, bus);
fail_unless (gst_element_set_state (aacparse,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
if (srccaps) {
gst_caps_unref (srccaps);
}
ts_counter = offset_counter = buffer_counter = 0;
buffers = NULL;
return aacparse;
}
static void
udpsink_test (gboolean use_buffer_lists)
{
GstElement *udpsink;
GstPad *srcpad;
GstBufferList *list;
guint data_size;
list = _create_buffer_list (&data_size);
udpsink = gst_check_setup_element ("udpsink");
if (use_buffer_lists)
_set_render_function (udpsink);
srcpad = gst_check_setup_src_pad_by_name (udpsink, &srctemplate, "sink");
gst_element_set_state (udpsink, GST_STATE_PLAYING);
gst_pad_push_event (srcpad, gst_event_new_new_segment_full (FALSE, 1.0, 1.0,
GST_FORMAT_TIME, 0, -1, 0));
gst_pad_push_list (srcpad, list);
gst_check_teardown_pad_by_name (udpsink, "sink");
gst_check_teardown_element (udpsink);
if (use_buffer_lists)
fail_if (data_size != render_list_bytes_received);
}
static GstElement *
setup_vp8enc (const gchar * src_caps_str)
{
GstElement *vp8enc;
GstCaps *srccaps = NULL;
GstBus *bus;
if (src_caps_str) {
srccaps = gst_caps_from_string (src_caps_str);
fail_unless (srccaps != NULL);
}
vp8enc = gst_check_setup_element ("vp8enc");
fail_unless (vp8enc != NULL);
srcpad = gst_check_setup_src_pad (vp8enc, &srctemplate);
sinkpad = gst_check_setup_sink_pad (vp8enc, &sinktemplate);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
gst_check_setup_events (srcpad, vp8enc, srccaps, GST_FORMAT_TIME);
bus = gst_bus_new ();
gst_element_set_bus (vp8enc, bus);
fail_unless (gst_element_set_state (vp8enc,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
if (srccaps)
gst_caps_unref (srccaps);
buffers = NULL;
return vp8enc;
}
static void
setup (void)
{
GstTagSetter *setter;
gchar *desc_str;
GstCaps *filter_caps;
GstBus *bus;
gint i;
GST_INFO ("init");
main_loop = g_main_loop_new (NULL, TRUE);
camera = gst_check_setup_element ("camerabin");
setup_camerabin_elements (camera);
g_signal_connect (camera, "image-done", G_CALLBACK (capture_done), main_loop);
bus = gst_pipeline_get_bus (GST_PIPELINE (camera));
gst_bus_add_watch (bus, (GstBusFunc) capture_bus_cb, main_loop);
gst_bus_set_sync_handler (bus, bus_sync_callback, main_loop);
gst_object_unref (bus);
filter_caps = gst_caps_from_string ("video/x-raw-yuv,format=(fourcc)I420");
g_object_set (G_OBJECT (camera), "filter-caps", filter_caps, NULL);
gst_caps_unref (filter_caps);
/* force a low framerate here to not timeout the tests because of the
* encoders */
g_signal_emit_by_name (camera, "set-video-resolution-fps", 320, 240, 5, 1,
NULL);
/* Set some default tags */
setter = GST_TAG_SETTER (camera);
desc_str = g_strdup_printf ("Created by %s", g_get_real_name ());
gst_tag_setter_add_tags (setter, GST_TAG_MERGE_REPLACE,
GST_TAG_DESCRIPTION, desc_str, NULL);
g_free (desc_str);
if (gst_element_set_state (GST_ELEMENT (camera), GST_STATE_PLAYING) ==
GST_STATE_CHANGE_FAILURE) {
GST_WARNING ("setting camerabin to PLAYING failed");
gst_element_set_state (GST_ELEMENT (camera), GST_STATE_NULL);
gst_object_unref (camera);
camera = NULL;
}
/* create the taglists */
for (i = 0; i < TAGLISTS_COUNT; i++) {
taglists[i] = gst_tag_list_new_full (GST_TAG_ARTIST, "test-artist",
GST_TAG_GEO_LOCATION_LONGITUDE, g_random_double_range (-180, 180),
GST_TAG_GEO_LOCATION_LATITUDE, g_random_double_range (-90, 90),
GST_TAG_GEO_LOCATION_ELEVATION, g_random_double_range (0, 3000), NULL);
}
GST_INFO ("init finished");
}
static GstElement *
setup_curlfilesink (void)
{
GST_DEBUG ("setup_curlfielsink");
sink = gst_check_setup_element ("curlfilesink");
srcpad = gst_check_setup_src_pad (sink, &srctemplate);
gst_pad_set_active (srcpad, TRUE);
return sink;
}
static GstElement *
setup_curlsmtpsink (void)
{
GST_DEBUG ("setup_curlsmtpsink");
sink = gst_check_setup_element ("curlsmtpsink");
srcpad = gst_check_setup_src_pad (sink, &srctemplate);
fail_unless (gst_pad_set_active (srcpad, TRUE));
return sink;
}
static void
setup (void)
{
element = gst_check_setup_element ("rtponviftimestamp");
mysinkpad = gst_check_setup_sink_pad (element, &sinktemplate);
gst_pad_set_active (mysinkpad, TRUE);
mysrcpad = gst_check_setup_src_pad (element, &srctemplate);
gst_pad_set_active (mysrcpad, TRUE);
}
static GstElement *
setup_multifdsink (void)
{
GstElement *multifdsink;
GST_DEBUG ("setup_multifdsink");
multifdsink = gst_check_setup_element ("multifdsink");
mysrcpad = gst_check_setup_src_pad (multifdsink, &srctemplate, NULL);
return multifdsink;
}
static GstElement *
setup_filesink (void)
{
GstElement *filesink;
GST_DEBUG ("setup_filesink");
filesink = gst_check_setup_element ("filesink");
mysrcpad = gst_check_setup_src_pad (filesink, &srctemplate);
gst_pad_set_active (mysrcpad, TRUE);
return filesink;
}
static GstElement *
setup_gnomevfssink (void)
{
GstElement *gnomevfssink;
GST_DEBUG ("setup_gnomevfssink");
gnomevfssink = gst_check_setup_element ("gnomevfssink");
mysrcpad = gst_check_setup_src_pad (gnomevfssink, &srctemplate, NULL);
gst_pad_set_active (mysrcpad, TRUE);
return gnomevfssink;
}
static GstElement *
setup_audioresample (int channels, int inrate, int outrate, int width,
gboolean fp)
{
GstElement *audioresample;
GstCaps *caps;
GstStructure *structure;
GST_DEBUG ("setup_audioresample");
audioresample = gst_check_setup_element ("audioresample");
if (fp)
caps = gst_caps_from_string (RESAMPLE_CAPS_FLOAT);
else
caps = gst_caps_from_string (RESAMPLE_CAPS_INT);
structure = gst_caps_get_structure (caps, 0);
gst_structure_set (structure, "channels", G_TYPE_INT, channels,
"rate", G_TYPE_INT, inrate, "width", G_TYPE_INT, width, NULL);
if (!fp)
gst_structure_set (structure, "depth", G_TYPE_INT, width, NULL);
fail_unless (gst_caps_is_fixed (caps));
fail_unless (gst_element_set_state (audioresample,
GST_STATE_PAUSED) == GST_STATE_CHANGE_SUCCESS,
"could not set to paused");
mysrcpad = gst_check_setup_src_pad (audioresample, &srctemplate, caps);
gst_pad_set_caps (mysrcpad, caps);
gst_caps_unref (caps);
if (fp)
caps = gst_caps_from_string (RESAMPLE_CAPS_FLOAT);
else
caps = gst_caps_from_string (RESAMPLE_CAPS_INT);
structure = gst_caps_get_structure (caps, 0);
gst_structure_set (structure, "channels", G_TYPE_INT, channels,
"rate", G_TYPE_INT, outrate, "width", G_TYPE_INT, width, NULL);
if (!fp)
gst_structure_set (structure, "depth", G_TYPE_INT, width, NULL);
fail_unless (gst_caps_is_fixed (caps));
mysinkpad = gst_check_setup_sink_pad (audioresample, &sinktemplate, caps);
/* this installs a getcaps func that will always return the caps we set
* later */
gst_pad_set_caps (mysinkpad, caps);
gst_pad_use_fixed_caps (mysinkpad);
gst_pad_set_active (mysinkpad, TRUE);
gst_pad_set_active (mysrcpad, TRUE);
gst_caps_unref (caps);
return audioresample;
}
static GstElement *
setup_audiotestsrc (void)
{
GstElement *audiotestsrc;
GST_DEBUG ("setup_audiotestsrc");
audiotestsrc = gst_check_setup_element ("audiotestsrc");
mysinkpad = gst_check_setup_sink_pad (audiotestsrc, &sinktemplate);
gst_pad_set_active (mysinkpad, TRUE);
return audiotestsrc;
}
static GstElement *
setup_multisocketsink (void)
{
GstElement *multisocketsink;
GST_DEBUG ("setup_multisocketsink");
multisocketsink = gst_check_setup_element ("multisocketsink");
mysrcpad = gst_check_setup_src_pad (multisocketsink, &srctemplate);
gst_pad_set_active (mysrcpad, TRUE);
return multisocketsink;
}
static void
setup_output_selector (void)
{
sel = gst_check_setup_element ("output-selector");
input_pad = gst_check_setup_src_pad (sel, &srctemplate);
gst_pad_set_active (input_pad, TRUE);
output_pads = g_list_append (output_pads, setup_output_pad (sel,
&sinktmpl_nego_a));
output_pads = g_list_append (output_pads, setup_output_pad (sel,
&sinktmpl_nego_b));
}
static GstElement *
setup_fdsrc (void)
{
GstElement *fdsrc;
GST_DEBUG ("setup_fdsrc");
fdsrc = gst_check_setup_element ("fdsrc");
mysinkpad = gst_check_setup_sink_pad (fdsrc, &sinktemplate, NULL);
gst_pad_set_event_function (mysinkpad, event_func);
gst_pad_set_active (mysinkpad, TRUE);
return fdsrc;
}
static GstElement *
setup_videotestsrc (void)
{
GstElement *videotestsrc;
GST_DEBUG ("setup_videotestsrc");
videotestsrc = gst_check_setup_element ("videotestsrc");
mysinkpad = gst_check_setup_sink_pad (videotestsrc, &sinktemplate, NULL);
gst_pad_set_active (mysinkpad, TRUE);
return videotestsrc;
}
static void
setup_multisocketsink_and_socketsrc (SymmetryTest * st)
{
GSocket *sockets[2] = { NULL, NULL };
GError *err = NULL;
st->sink = gst_check_setup_element ("multisocketsink");
st->src = gst_check_setup_element ("socketsrc");
fail_unless (g_socketpair (G_SOCKET_FAMILY_UNIX,
G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, sockets, &err));
g_object_set (st->src, "socket", sockets[0], NULL);
g_object_unref (sockets[0]);
sockets[0] = NULL;
symmetry_test_setup (st, st->sink, st->src);
g_signal_emit_by_name (st->sink, "add", sockets[1], NULL);
g_object_unref (sockets[1]);
sockets[1] = NULL;
}
static GstElement *
setup_appsrc (void)
{
GstElement *appsrc;
GST_DEBUG ("setup_appsrc");
appsrc = gst_check_setup_element ("appsrc");
mysinkpad = gst_check_setup_sink_pad (appsrc, &sinktemplate, NULL);
gst_pad_set_active (mysinkpad, TRUE);
return appsrc;
}
void test_large_discont()
{
GstElement *audiorate;
GstCaps *caps;
GstPad *srcpad, *sinkpad;
GstBuffer *buf;
//xmlfile = "test_large_discont";
std_log(LOG_FILENAME_LINE, "Test Started test_large_discont");
audiorate = gst_check_setup_element ("audiorate");
caps = gst_caps_new_simple ("audio/x-raw-float",
"channels", G_TYPE_INT, 1,
"rate", G_TYPE_INT, 44100, "width", G_TYPE_INT, 32, NULL);
srcpad = gst_check_setup_src_pad (audiorate, &srctemplate, caps);
sinkpad = gst_check_setup_sink_pad (audiorate, &sinktemplate, caps);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
fail_unless (gst_element_set_state (audiorate,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"failed to set audiorate playing");
buf = gst_buffer_new_and_alloc (4);
gst_buffer_set_caps (buf, caps);
GST_BUFFER_TIMESTAMP (buf) = 0;
gst_pad_push (srcpad, buf);
fail_unless_equals_int (g_list_length (buffers), 1);
buf = gst_buffer_new_and_alloc (4);
gst_buffer_set_caps (buf, caps);
GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
gst_pad_push (srcpad, buf);
/* Now we should have 3 more buffers: the one we injected, plus _two_ filler
* buffers, because the gap is > 1 second (but less than 2 seconds) */
fail_unless_equals_int (g_list_length (buffers), 4);
gst_element_set_state (audiorate, GST_STATE_NULL);
gst_caps_unref (caps);
gst_check_teardown_sink_pad (audiorate);
gst_check_teardown_src_pad (audiorate);
gst_object_unref (audiorate);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
