static void
snra_client_finalize (GObject * object)
{
SnraClient *client = (SnraClient *) (object);
if (client->avahi_sb)
avahi_service_browser_free (client->avahi_sb);
if (client->avahi_client)
avahi_client_free (client->avahi_client);
if (client->glib_poll)
avahi_glib_poll_free (client->glib_poll);
if (client->net_clock)
gst_object_unref (client->net_clock);
if (client->soup)
g_object_unref (client->soup);
if (client->json)
g_object_unref (client->json);
if (client->player) {
GstBus *bus = gst_element_get_bus (client->player);
gst_bus_remove_signal_watch (bus);
gst_object_unref (bus);
gst_object_unref (client->player);
}
g_free (client->server_host);
g_free (client->connected_server);
G_OBJECT_CLASS (snra_client_parent_class)->finalize (object);
}
AudioFileReader::~AudioFileReader()
{
if (m_pipeline) {
GRefPtr<GstBus> bus = webkitGstPipelineGetBus(GST_PIPELINE(m_pipeline));
ASSERT(bus);
g_signal_handlers_disconnect_by_func(bus.get(), reinterpret_cast<gpointer>(messageCallback), this);
gst_bus_remove_signal_watch(bus.get());
gst_element_set_state(m_pipeline, GST_STATE_NULL);
gst_object_unref(GST_OBJECT(m_pipeline));
}
if (m_decodebin) {
g_signal_handlers_disconnect_by_func(m_decodebin.get(), reinterpret_cast<gpointer>(onGStreamerDecodebinPadAddedCallback), this);
m_decodebin.clear();
}
if (m_deInterleave) {
g_signal_handlers_disconnect_by_func(m_deInterleave.get(), reinterpret_cast<gpointer>(onGStreamerDeinterleavePadAddedCallback), this);
g_signal_handlers_disconnect_by_func(m_deInterleave.get(), reinterpret_cast<gpointer>(onGStreamerDeinterleaveReadyCallback), this);
m_deInterleave.clear();
}
#ifndef GST_API_VERSION_1
gst_buffer_list_iterator_free(m_frontLeftBuffersIterator);
gst_buffer_list_iterator_free(m_frontRightBuffersIterator);
#endif
gst_buffer_list_unref(m_frontLeftBuffers);
gst_buffer_list_unref(m_frontRightBuffers);
}
AlertTonePreview::~AlertTonePreview ()
{
SYS_DEBUG ("Stopping the playback.");
if (m_gstVolume)
{
gst_object_unref (m_gstVolume);
m_gstVolume = NULL;
}
GstBus *bus = gst_element_get_bus (m_gstPipeline);
gst_bus_remove_signal_watch (bus);
gst_object_unref (bus);
gst_element_set_state (m_gstPipeline, GST_STATE_NULL);
gst_object_unref (m_gstPipeline);
m_gstPipeline = NULL;
#ifdef HAVE_LIBRESOURCEQT
disconnect (resources,
SIGNAL (resourcesGranted (QList<ResourcePolicy::ResourceType>)),
this,
SLOT (audioResourceAcquired ()));
disconnect (resources,
SIGNAL (lostResources ()),
this,
SLOT (audioResourceLost()));
resources->release ();
#endif
}
MediaPipeline::~MediaPipeline() throw()
{
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline) );
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
gst_element_set_state (pipeline, GST_STATE_NULL);
g_object_unref (pipeline);
}
static void
execute_test (int count)
{
guint timeout_id;
gchar *name = g_strdup_printf ("negotiation_test_%d", count);
GstElement *pipeline = gst_pipeline_new (name);
GstElement *audiotestsrc = gst_element_factory_make ("audiotestsrc", NULL);
GstElement *tee = gst_element_factory_make ("tee", "tee");
GstElement *queue = gst_element_factory_make ("queue", NULL);
GstElement *sink = gst_element_factory_make ("appsink", NULL);
gint *branches, i;
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
g_free (name);
if (bus == NULL) {
GST_ERROR ("Bus is NULL");
g_atomic_int_set (&error, 1);
return;
}
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_message), pipeline);
g_object_set (G_OBJECT (sink), "emit-signals", TRUE, "sync", FALSE, NULL);
g_signal_connect_data (G_OBJECT (sink), "new-sample", G_CALLBACK (new_sample),
NULL, NULL, 0);
branches = g_malloc0 (sizeof (gint));
*branches = N_BRANCHES;
g_object_set_data_full (G_OBJECT (pipeline), BRANCHES_COUNT_KEY, branches, g_free);
GST_INFO ("Connecting %d branches", N_BRANCHES);
for (i = 1; i < N_BRANCHES; i++) {
g_timeout_add (500, connect_branch, pipeline);
}
gst_bin_add_many (GST_BIN (pipeline), audiotestsrc, tee, queue, sink, NULL);
gst_element_link_many (audiotestsrc, tee, queue, sink, NULL);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
timeout_id = g_timeout_add_seconds (35, timeout_check, pipeline);
g_main_loop_run (loop);
if (!g_source_remove (timeout_id)) {
GST_ERROR ("Error removing source");
g_atomic_int_set (&error, 1);
return;
}
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
}
GST_END_TEST
GST_START_TEST (connection_of_elements_data)
{
gchar *padname = NULL;
KmsConnectData *data;
GstBus *bus;
data = kms_connect_data_create (MAX_CHECKS);
data->data_probe = (KmsProbeType) data_probe_cb;
data->audio_probe = (KmsProbeType) audio_probe_cb;
data->video_probe = (KmsProbeType) video_probe_cb;
/* Only tests data */
data->video_checks = data->audio_checks = 0;
loop = g_main_loop_new (NULL, TRUE);
pipeline = gst_pipeline_new (__FUNCTION__);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
data->src = gst_element_factory_make ("dummysrc", NULL);
data->sink = gst_element_factory_make ("dummysink", NULL);
g_signal_connect (data->src, "pad-added", G_CALLBACK (src_pads_added), data);
g_signal_connect (data->sink, "pad-added",
G_CALLBACK (sink_pads_added), data);
g_signal_connect (data->sink, "pad-removed",
G_CALLBACK (sink_pads_removed), data);
gst_bin_add_many (GST_BIN (pipeline), data->src, data->sink, NULL);
/* request src pad using action */
g_signal_emit_by_name (data->src, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_DATA, NULL, GST_PAD_SRC, &data->data_src);
fail_if (data->data_src == NULL);
GST_DEBUG ("Data pad name %s", data->data_src);
g_object_set (G_OBJECT (data->src), "data", TRUE, NULL);
g_object_set (G_OBJECT (data->sink), "data", TRUE, NULL);
g_timeout_add_seconds (4, print_timedout_pipeline, NULL);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_main_loop_run (loop);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_free (padname);
g_main_loop_unref (loop);
kms_connect_data_destroy (data);
}
AudioDestinationGStreamer::~AudioDestinationGStreamer()
{
GRefPtr<GstBus> bus = adoptGRef(gst_pipeline_get_bus(GST_PIPELINE(m_pipeline)));
ASSERT(bus);
g_signal_handlers_disconnect_by_func(bus.get(), reinterpret_cast<gpointer>(messageCallback), this);
gst_bus_remove_signal_watch(bus.get());
gst_element_set_state(m_pipeline, GST_STATE_NULL);
gst_object_unref(m_pipeline);
}
GST_END_TEST
GST_START_TEST (reconnect_test)
{
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
GstElement *pipeline = gst_pipeline_new (__FUNCTION__);
GstElement *videotestsrc = gst_element_factory_make ("videotestsrc", NULL);
GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
GstElement *decoder = gst_element_factory_make ("vp8dec", NULL);
GstElement *fakesink2 = gst_element_factory_make ("fakesink", NULL);
gboolean ret;
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
g_object_set (G_OBJECT (videotestsrc), "is-live", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (fakesink2), "sync", FALSE, "signal-handoffs", TRUE,
NULL);
g_signal_connect (G_OBJECT (fakesink2), "handoff",
G_CALLBACK (fakesink_hand_off2), loop);
g_object_set_data (G_OBJECT (fakesink2), DECODER_KEY, decoder);
g_object_set_data (G_OBJECT (decoder), AGNOSTIC_KEY, agnosticbin);
g_object_set_data (G_OBJECT (decoder), FAKESINK_KEY, fakesink2);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), videotestsrc, agnosticbin, fakesink,
decoder, fakesink2, NULL);
mark_point ();
ret = gst_element_link_many (videotestsrc, agnosticbin, fakesink, NULL);
fail_unless (ret);
mark_point ();
ret = gst_element_link_many (agnosticbin, decoder, fakesink2, NULL);
fail_unless (ret);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_PLAYING);
mark_point ();
g_timeout_add_seconds (10, timeout_check, pipeline);
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_main_loop_unref (loop);
}
GST_END_TEST
GST_START_TEST (encoded_input_link)
{
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
GstElement *pipeline = gst_pipeline_new (__FUNCTION__);
GstElement *videotestsrc = gst_element_factory_make ("videotestsrc", NULL);
GstElement *encoder = gst_element_factory_make ("vp8enc", NULL);
GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
GstElement *filter = gst_element_factory_make ("capsfilter", NULL);
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
GstCaps *caps;
gboolean ret;
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (fakesink), "sync", FALSE, "signal-handoffs", TRUE,
NULL);
g_signal_connect (G_OBJECT (fakesink), "handoff",
G_CALLBACK (fakesink_hand_off), loop);
caps = gst_caps_from_string ("video/x-raw");
g_object_set (G_OBJECT (filter), "caps", caps, NULL);
gst_caps_unref (caps);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), videotestsrc, encoder, agnosticbin,
filter, fakesink, NULL);
mark_point ();
ret = gst_element_link_many (videotestsrc, encoder, agnosticbin, filter,
fakesink, NULL);
fail_unless (ret);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_PLAYING);
mark_point ();
g_timeout_add_seconds (10, timeout_check, pipeline);
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_main_loop_unref (loop);
}
static void
play_agnosticbin_vp8_to_raw (void)
{
gboolean ret;
GstElement *pipeline = gst_pipeline_new (NULL);
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
GstElement *videotestsrc = gst_element_factory_make ("videotestsrc", NULL);
GstElement *vp8enc = gst_element_factory_make ("vp8enc", NULL);
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
GstElement *capsfilter = gst_element_factory_make ("capsfilter", NULL);
GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
loop = g_main_loop_new (NULL, TRUE);
GstCaps *caps;
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
mark_point ();
g_object_set (G_OBJECT (videotestsrc), "num-buffers", 100, NULL);
g_object_set (G_OBJECT (vp8enc), "keyframe-max-dist", 1, NULL);
caps = gst_caps_new_empty_simple ("video/x-raw");
g_object_set (G_OBJECT (capsfilter), "caps", caps, NULL);
gst_caps_unref (caps);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), videotestsrc, vp8enc, agnosticbin,
capsfilter, fakesink, NULL);
mark_point ();
ret =
gst_element_link_many (videotestsrc, vp8enc, agnosticbin, capsfilter,
fakesink, NULL);
fail_unless (ret);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
mark_point ();
g_main_loop_run (loop);
mark_point ();
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "play_agnosticbin_vp8_to_raw_end");
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_main_loop_unref (loop);
g_object_unref (pipeline);
}
MediaPipelineImpl::~MediaPipelineImpl ()
{
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline) );
if (busMessageHandler > 0) {
unregister_signal_handler (bus, busMessageHandler);
}
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
gst_element_set_state (pipeline, GST_STATE_NULL);
g_object_unref (pipeline);
}
GST_END_TEST
GST_START_TEST (encoded_input_n_encoded_ouput)
{
loop = g_main_loop_new (NULL, TRUE);
GstElement *pipeline = gst_pipeline_new (__FUNCTION__);
GstElement *audiotestsrc = gst_element_factory_make ("audiotestsrc", NULL);
GstElement *encoder = gst_element_factory_make ("alawenc", NULL);
GstElement *agnosticbin =
gst_element_factory_make ("agnosticbin", "agnosticbin");
gboolean ret;
int *count, i;
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), audiotestsrc, encoder, agnosticbin,
NULL);
mark_point ();
ret = gst_element_link_many (audiotestsrc, encoder, agnosticbin, NULL);
fail_unless (ret);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_PLAYING);
mark_point ();
count = g_malloc0 (sizeof (int));
*count = N_ITERS;
g_object_set_data_full (G_OBJECT (pipeline), COUNT_KEY, count, g_free);
GST_INFO ("Connecting %d outputs", N_ITERS);
g_timeout_add_seconds (6, timeout_check, pipeline);
for (i = 0; i < N_ITERS; i++) {
g_timeout_add (700, connect_output, pipeline);
}
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_main_loop_unref (loop);
}
static void
kms_http_post_endpoint_finalize (GObject * object)
{
KmsHttpPostEndpoint *self = KMS_HTTP_POST_ENDPOINT (object);
if (self->priv->bus != NULL) {
if (self->priv->handler_id > 0) {
g_signal_handler_disconnect (self->priv->bus, self->priv->handler_id);
}
gst_bus_remove_signal_watch (self->priv->bus);
g_object_unref (self->priv->bus);
}
G_OBJECT_CLASS (kms_http_post_endpoint_parent_class)->finalize (object);
}
static void
play_agnosticbin_raw_to_vorbis (void)
{
gboolean ret;
GstElement *pipeline = gst_pipeline_new (NULL);
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
GstElement *audiotestsrc = gst_element_factory_make ("audiotestsrc", NULL);
GstElement *vorbisdec = gst_element_factory_make ("vorbisdec", NULL);
GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
loop = g_main_loop_new (NULL, TRUE);
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (audiotestsrc), "num-buffers", 100, "is-live", TRUE,
NULL);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), audiotestsrc, agnosticbin, vorbisdec,
fakesink, NULL);
mark_point ();
ret =
gst_element_link_many (audiotestsrc, agnosticbin, vorbisdec, fakesink,
NULL);
fail_unless (ret);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_timeout_add_seconds (10, timeout_check, pipeline);
mark_point ();
g_main_loop_run (loop);
mark_point ();
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, __FUNCTION__);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_main_loop_unref (loop);
g_object_unref (pipeline);
}
/**
* gst_bus_poll:
* @bus: a #GstBus
* @events: a mask of #GstMessageType, representing the set of message types to
* poll for (note special handling of extended message types below)
* @timeout: the poll timeout, as a #GstClockTime, or #GST_CLOCK_TIME_NONE to poll
* indefinitely.
*
* Poll the bus for messages. Will block while waiting for messages to come.
* You can specify a maximum time to poll with the @timeout parameter. If
* @timeout is negative, this function will block indefinitely.
*
* All messages not in @events will be popped off the bus and will be ignored.
* It is not possible to use message enums beyond #GST_MESSAGE_EXTENDED in the
* @events mask
*
* Because poll is implemented using the "message" signal enabled by
* gst_bus_add_signal_watch(), calling gst_bus_poll() will cause the "message"
* signal to be emitted for every message that poll sees. Thus a "message"
* signal handler will see the same messages that this function sees -- neither
* will steal messages from the other.
*
* This function will run a main loop from the default main context when
* polling.
*
* You should never use this function, since it is pure evil. This is
* especially true for GUI applications based on Gtk+ or Qt, but also for any
* other non-trivial application that uses the GLib main loop. As this function
* runs a GLib main loop, any callback attached to the default GLib main
* context may be invoked. This could be timeouts, GUI events, I/O events etc.;
* even if gst_bus_poll() is called with a 0 timeout. Any of these callbacks
* may do things you do not expect, e.g. destroy the main application window or
* some other resource; change other application state; display a dialog and
* run another main loop until the user clicks it away. In short, using this
* function may add a lot of complexity to your code through unexpected
* re-entrancy and unexpected changes to your application's state.
*
* For 0 timeouts use gst_bus_pop_filtered() instead of this function; for
* other short timeouts use gst_bus_timed_pop_filtered(); everything else is
* better handled by setting up an asynchronous bus watch and doing things
* from there.
*
* Returns: (transfer full) (nullable): the message that was received,
* or %NULL if the poll timed out. The message is taken from the
* bus and needs to be unreffed with gst_message_unref() after
* usage.
*/
GstMessage *
gst_bus_poll (GstBus * bus, GstMessageType events, GstClockTime timeout)
{
GstBusPollData *poll_data;
GstMessage *ret;
gulong id;
g_return_val_if_fail (GST_IS_BUS (bus), NULL);
poll_data = g_slice_new (GstBusPollData);
poll_data->source_running = TRUE;
poll_data->loop = g_main_loop_new (NULL, FALSE);
poll_data->events = events;
poll_data->message = NULL;
if (timeout != GST_CLOCK_TIME_NONE)
poll_data->timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
timeout / GST_MSECOND, (GSourceFunc) poll_timeout, poll_data,
(GDestroyNotify) poll_destroy_timeout);
else
poll_data->timeout_id = 0;
id = g_signal_connect_data (bus, "message", G_CALLBACK (poll_func), poll_data,
(GClosureNotify) poll_destroy, 0);
/* these can be nested, so it's ok */
gst_bus_add_signal_watch (bus);
GST_DEBUG ("running mainloop %p", poll_data->loop);
g_main_loop_run (poll_data->loop);
GST_DEBUG ("mainloop stopped %p", poll_data->loop);
gst_bus_remove_signal_watch (bus);
/* holds a ref */
ret = poll_data->message;
if (poll_data->timeout_id)
g_source_remove (poll_data->timeout_id);
/* poll_data will be freed now */
g_signal_handler_disconnect (bus, id);
GST_DEBUG_OBJECT (bus, "finished poll with message %p", ret);
return ret;
}
GST_END_TEST
GST_START_TEST (encoded_input_to_valve)
{
loop = g_main_loop_new (NULL, TRUE);
GstElement *pipeline = gst_pipeline_new (__FUNCTION__);
GstElement *audiotestsrc = gst_element_factory_make ("audiotestsrc", NULL);
GstElement *encoder = gst_element_factory_make ("alawenc", NULL);
GstElement *valve = gst_element_factory_make ("valve", "valve");
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
gboolean ret;
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (valve), "drop", TRUE, NULL);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), audiotestsrc, encoder, agnosticbin,
valve, NULL);
mark_point ();
ret = gst_element_link_many (audiotestsrc, encoder, agnosticbin, valve, NULL);
fail_unless (ret);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_PLAYING);
mark_point ();
g_timeout_add_seconds (6, timeout_check, pipeline);
g_timeout_add (700, connect_appsink, pipeline);
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_main_loop_unref (loop);
}
gboolean
check_run_main_loop_until_msg_or_error (BtSong * song, const gchar * msg)
{
GstStateChangeReturn sret;
GstState state, pending;
GMainLoop *main_loop = g_main_loop_new (NULL, FALSE);
GstElement *bin =
(GstElement *) check_gobject_get_object_property (song, "bin");
GstBus *bus = gst_element_get_bus (bin);
gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
g_signal_connect (bus, "message::error", G_CALLBACK (_check_message_received),
(gpointer) main_loop);
g_signal_connect (bus, msg,
G_CALLBACK (_check_message_received), (gpointer) main_loop);
_check_run_main_loop_error = FALSE;
sret = gst_element_get_state (bin, &state, &pending, G_GUINT64_CONSTANT (0));
// be careful to not run this when the song already finished
if (sret != GST_STATE_CHANGE_FAILURE) {
GST_INFO_OBJECT (song, "running main_loop: sret=%s, state=%s/%s",
gst_element_state_change_return_get_name (sret),
gst_element_state_get_name (state),
gst_element_state_get_name (pending));
g_main_loop_run (main_loop);
} else {
GST_INFO_OBJECT (song, "skipping main_loop: sret=%s, state=%s/%s",
gst_element_state_change_return_get_name (sret),
gst_element_state_get_name (state),
gst_element_state_get_name (pending));
}
gst_bus_remove_signal_watch (bus);
g_signal_handlers_disconnect_matched (bus, G_SIGNAL_MATCH_DATA, 0, 0, NULL,
NULL, (gpointer) main_loop);
gst_object_unref (bus);
gst_object_unref (bin);
g_main_loop_unref (main_loop);
GST_INFO_OBJECT (song, "finished main_loop");
return sret == GST_STATE_CHANGE_FAILURE ? FALSE : !_check_run_main_loop_error;
}
GST_END_TEST
GST_START_TEST (request_audio_src_pad_pending)
{
GstElement *dummysrc;
gchar *padname = NULL;
GstBus *bus;
loop = g_main_loop_new (NULL, TRUE);
pipeline = gst_pipeline_new (__FUNCTION__);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
dummysrc = gst_element_factory_make ("dummysrc", NULL);
g_signal_connect (dummysrc, "pad-added", G_CALLBACK (pad_added_delayed),
&padname);
gst_bin_add (GST_BIN (pipeline), dummysrc);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
/* request src pad using action */
g_signal_emit_by_name (dummysrc, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_AUDIO, NULL, GST_PAD_SRC, &padname);
fail_if (padname == NULL);
GST_DEBUG ("Pad name %s", padname);
g_object_set (G_OBJECT (dummysrc), "audio", TRUE, NULL);
g_free (padname);
g_timeout_add_seconds (4, print_timedout_pipeline, NULL);
g_main_loop_run (loop);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_main_loop_unref (loop);
}
GST_END_TEST
GST_START_TEST (add_later)
{
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
GstElement *pipeline = gst_pipeline_new (__FUNCTION__);
GstElement *videosrc = gst_element_factory_make ("videotestsrc", NULL);
GstElement *typefind = gst_element_factory_make ("typefind", NULL);
GstElement *fakesink = gst_element_factory_make ("fakesink", "fakesink");
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (fakesink), "sync", FALSE, "signal-handoffs", TRUE,
NULL);
g_signal_connect (G_OBJECT (fakesink), "handoff",
G_CALLBACK (fakesink_hand_off), loop);
g_signal_connect (G_OBJECT (typefind), "have-type", G_CALLBACK (type_found),
pipeline);
gst_bin_add_many (GST_BIN (pipeline), videosrc, typefind, fakesink, NULL);
gst_element_link (videosrc, typefind);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_timeout_add_seconds (10, timeout_check, pipeline);
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (pipeline);
g_object_unref (bus);
g_main_loop_unref (loop);
}
static void
play_agnosticbin_video_passthrough (void)
{
gboolean ret;
GstElement *pipeline = gst_pipeline_new (NULL);
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
GstElement *videotestsrc = gst_element_factory_make ("videotestsrc", NULL);
GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
loop = g_main_loop_new (NULL, TRUE);
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (videotestsrc), "num-buffers", 100, NULL);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), videotestsrc, agnosticbin, fakesink,
NULL);
mark_point ();
ret = gst_element_link_many (videotestsrc, agnosticbin, fakesink, NULL);
fail_unless (ret);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_main_loop_unref (loop);
g_object_unref (pipeline);
}
static void
start_playerendpoint (void)
{
GstElement *pipeline = gst_pipeline_new (NULL);
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
GstElement *playerendpoint =
gst_element_factory_make ("playerendpoint", NULL);
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
g_object_set (G_OBJECT (pipeline), "async-handling", TRUE, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_signal_connect (G_OBJECT (playerendpoint), "eos",
G_CALLBACK (playerendpoint_eos), loop);
g_object_set (G_OBJECT (playerendpoint), "uri",
"http://ci.kurento.com/downloads/small.webm", NULL);
gst_bin_add (GST_BIN (pipeline), playerendpoint);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
mark_point ();
g_object_set (G_OBJECT (playerendpoint), "state",
KMS_URI_END_POINT_STATE_START, NULL);
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_main_loop_unref (loop);
g_object_unref (pipeline);
}
GST_END_TEST
GST_START_TEST (delay_stream)
{
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
GstElement *pipeline = gst_pipeline_new (__FUNCTION__);
GstElement *agnosticbin =
gst_element_factory_make ("agnosticbin", "agnosticbin");
GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (fakesink), "async", FALSE, "sync", FALSE,
"signal-handoffs", TRUE, NULL);
g_signal_connect (G_OBJECT (fakesink), "handoff",
G_CALLBACK (fakesink_hand_off), loop);
gst_bin_add_many (GST_BIN (pipeline), agnosticbin, fakesink, NULL);
gst_element_link (agnosticbin, fakesink);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_timeout_add_seconds (1, link_source, pipeline);
g_timeout_add_seconds (11, timeout_check, pipeline);
mark_point ();
g_main_loop_run (loop);
mark_point ();
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (pipeline);
g_object_unref (bus);
g_main_loop_unref (loop);
}
static void
_test_negotiation (const gchar * src_templ, const gchar * sink_templ,
gint width, gint height, gint par_n, gint par_d)
{
GstElement *pipeline;
GstElement *src, *capsfilter1, *scale, *capsfilter2, *sink;
GstBus *bus;
GMainLoop *loop;
GstCaps *caps;
TestNegotiationData data = { 0, 0, 0, 0, FALSE, NULL };
GstPad *pad;
GST_DEBUG ("Running test for src templ caps '%s' and sink templ caps '%s'",
src_templ, sink_templ);
pipeline = gst_element_factory_make ("pipeline", "pipeline");
fail_unless (pipeline != NULL);
src = gst_element_factory_make ("videotestsrc", "src");
fail_unless (src != NULL);
g_object_set (G_OBJECT (src), "num-buffers", 1, NULL);
capsfilter1 = gst_element_factory_make ("capsfilter", "filter1");
fail_unless (capsfilter1 != NULL);
caps = gst_caps_from_string (src_templ);
fail_unless (caps != NULL);
g_object_set (G_OBJECT (capsfilter1), "caps", caps, NULL);
gst_caps_unref (caps);
scale = gst_element_factory_make ("videoscale", "scale");
fail_unless (scale != NULL);
capsfilter2 = gst_element_factory_make ("capsfilter", "filter2");
fail_unless (capsfilter2 != NULL);
caps = gst_caps_from_string (sink_templ);
fail_unless (caps != NULL);
g_object_set (G_OBJECT (capsfilter2), "caps", caps, NULL);
gst_caps_unref (caps);
pad = gst_element_get_static_pad (capsfilter2, "sink");
fail_unless (pad != NULL);
g_signal_connect (pad, "notify::caps",
G_CALLBACK (_test_negotiation_notify_caps), &data);
gst_object_unref (pad);
sink = gst_element_factory_make ("fakesink", "sink");
fail_unless (sink != NULL);
g_object_set (sink, "async", FALSE, NULL);
gst_bin_add_many (GST_BIN (pipeline), src, capsfilter1, scale, capsfilter2,
sink, NULL);
fail_unless (gst_element_link_pads_full (src, "src", capsfilter1, "sink",
LINK_CHECK_FLAGS));
fail_unless (gst_element_link_pads_full (capsfilter1, "src", scale, "sink",
LINK_CHECK_FLAGS));
fail_unless (gst_element_link_pads_full (scale, "src", capsfilter2, "sink",
LINK_CHECK_FLAGS));
fail_unless (gst_element_link_pads_full (capsfilter2, "src", sink, "sink",
LINK_CHECK_FLAGS));
loop = g_main_loop_new (NULL, FALSE);
bus = gst_element_get_bus (pipeline);
fail_unless (bus != NULL);
gst_bus_add_signal_watch (bus);
data.loop = loop;
data.width = width;
data.height = height;
data.par_n = par_n;
data.par_d = par_d;
data.ok = FALSE;
g_signal_connect (bus, "message", G_CALLBACK (_test_negotiation_message),
&data);
gst_bus_remove_signal_watch (bus);
gst_object_unref (bus);
fail_unless (gst_element_set_state (pipeline,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS);
g_main_loop_run (loop);
fail_unless (data.ok == TRUE);
fail_unless (gst_element_set_state (pipeline,
GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS);
gst_object_unref (pipeline);
g_main_loop_unref (loop);
}
gboolean
ges_generate_test_file_audio_video (const gchar * filedest,
const gchar * audio_enc,
const gchar * video_enc,
const gchar * mux, const gchar * video_pattern, const gchar * audio_wave)
{
GError *error = NULL;
GstElement *pipeline;
GstBus *bus;
GstMessage *message;
gchar *pipeline_str;
gboolean done = FALSE;
gboolean ret = FALSE;
if (g_file_test (filedest, G_FILE_TEST_EXISTS)) {
GST_INFO ("The file %s already existed.", filedest);
return TRUE;
}
pipeline_str = g_strdup_printf ("audiotestsrc num-buffers=430 wave=%s "
"%c %s ! %s name=m ! filesink location= %s/%s "
"videotestsrc pattern=%s num-buffers=300 ! %s ! m.",
audio_wave,
audio_enc ? '!' : ' ',
audio_enc ? audio_enc : "",
mux, g_get_current_dir (), filedest, video_pattern, video_enc);
pipeline = gst_parse_launch (pipeline_str, &error);
if (pipeline == NULL)
return FALSE;
g_free (pipeline_str);
bus = gst_element_get_bus (GST_ELEMENT (pipeline));
gst_bus_add_signal_watch (bus);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
while (!done) {
message = gst_bus_poll (bus, GST_MESSAGE_ANY, GST_CLOCK_TIME_NONE);
if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_EOS) {
done = TRUE;
ret = TRUE;
} else if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) {
gchar *debug = NULL;
GError *err = NULL;
gst_message_parse_error (message, &err, &debug);
done = TRUE;
ret = FALSE;
GST_ERROR ("Got error %s from %s fron the bus while generation: %s"
"debug infos: %s", GST_OBJECT_NAME (message->src), err->message,
debug ? debug : "none", filedest);
g_clear_error (&err);
g_free (debug);
}
}
gst_bus_remove_signal_watch (bus);
gst_object_unref (bus);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
return ret;
}
GST_END_TEST
/* Temporaly disabled */
#if 0
GST_START_TEST (test_dtls_send_recv_data)
{
gchar *cert_key_pem_file;
GTlsConnection *conn;
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
GstElement *pipeline = gst_pipeline_new (__FUNCTION__);
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
GstElement *fakesrc_client = gst_element_factory_make ("fakesrc", NULL);
GstElement *dtlsenc_client = gst_element_factory_make ("kmsdtlsenc", NULL);
GstElement *dtlsdec_client = gst_element_factory_make ("kmsdtlsdec", NULL);
GstElement *fakesink_client = gst_element_factory_make ("fakesink", NULL);
GstElement *fakesrc_server = gst_element_factory_make ("fakesrc", NULL);
GstElement *dtlsenc_server = gst_element_factory_make ("kmsdtlsenc", NULL);
GstElement *dtlsdec_server = gst_element_factory_make ("kmsdtlsdec", NULL);
GstElement *fakesink_server = gst_element_factory_make ("fakesink", NULL);
cert_key_pem_file = generate_certkey_pem_file_path ();
generate_certkey_pem_file (cert_key_pem_file);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
g_object_set (G_OBJECT (fakesink_client), "signal-handoffs", TRUE, NULL);
g_signal_connect (G_OBJECT (fakesink_client), "handoff",
G_CALLBACK (fakesink_dtls_client_hand_off), loop);
g_object_set (G_OBJECT (fakesink_server), "signal-handoffs", TRUE, NULL);
g_signal_connect (G_OBJECT (fakesink_server), "handoff",
G_CALLBACK (fakesink_dtls_server_hand_off), loop);
g_object_set (G_OBJECT (fakesrc_client), "sizetype", 2, NULL);
g_object_set (G_OBJECT (fakesrc_server), "sizetype", 2, NULL);
g_object_set (G_OBJECT (dtlsenc_client), "channel-id", "client-id", NULL);
g_object_set (G_OBJECT (dtlsenc_client), "is-client", TRUE, NULL);
g_object_set (G_OBJECT (dtlsdec_client), "channel-id", "client-id", NULL);
g_object_set (G_OBJECT (dtlsdec_client), "is-client", TRUE, NULL);
g_object_set (G_OBJECT (dtlsdec_client), "certificate-pem-file",
cert_key_pem_file, NULL);
g_object_set (G_OBJECT (dtlsenc_server), "channel-id", "server-id", NULL);
g_object_set (G_OBJECT (dtlsenc_server), "is-client", FALSE, NULL);
g_object_set (G_OBJECT (dtlsdec_server), "channel-id", "server-id", NULL);
g_object_set (G_OBJECT (dtlsdec_server), "is-client", FALSE, NULL);
g_object_set (G_OBJECT (dtlsdec_server), "certificate-pem-file",
cert_key_pem_file, NULL);
mark_point ();
gst_bin_add_many (GST_BIN (pipeline), fakesrc_client, dtlsdec_client,
dtlsenc_client, fakesink_client, NULL);
gst_bin_add_many (GST_BIN (pipeline), fakesrc_server, dtlsdec_server,
dtlsenc_server, fakesink_server, NULL);
mark_point ();
gst_element_link_many (fakesrc_client, dtlsenc_client, dtlsdec_server,
fakesink_server, NULL);
gst_element_link_many (fakesrc_server, dtlsenc_server, dtlsdec_client,
fakesink_client, NULL);
mark_point ();
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "dtls_before_playing");
gst_element_set_state (fakesink_server, GST_STATE_PLAYING);
gst_element_set_state (dtlsdec_server, GST_STATE_PLAYING);
gst_element_set_state (dtlsenc_client, GST_STATE_PLAYING);
gst_element_set_state (fakesrc_client, GST_STATE_PLAYING);
gst_element_set_state (fakesink_client, GST_STATE_PLAYING);
gst_element_set_state (dtlsdec_client, GST_STATE_PLAYING);
gst_element_set_state (dtlsenc_server, GST_STATE_PLAYING);
gst_element_set_state (fakesrc_server, GST_STATE_PLAYING);
/* Init DTLS handshake over dtlsenc connection */
g_object_get (dtlsenc_client, "tls-connection", &conn, NULL);
g_tls_connection_handshake_async (conn, G_PRIORITY_DEFAULT, NULL, NULL, NULL);
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "dtls_before_entering_loop");
g_main_loop_run (loop);
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "dtls_end");
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_main_loop_unref (loop);
g_remove (cert_key_pem_file);
g_free (cert_key_pem_file);
}
/*
* Create a demux element, run a test using the input data and check
* the output data
*/
void
gst_adaptive_demux_test_run (const gchar * element_name,
const gchar * manifest_uri,
const GstAdaptiveDemuxTestCallbacks * callbacks, gpointer user_data)
{
GstBus *bus;
GstElement *demux;
GstElement *manifest_source;
gboolean ret;
GstStateChangeReturn stateChange;
GstAdaptiveDemuxTestEnginePrivate *priv;
priv = g_slice_new0 (GstAdaptiveDemuxTestEnginePrivate);
priv->engine.output_streams =
g_ptr_array_new_with_free_func
(adaptive_demux_engine_stream_state_finalize);
g_mutex_init (&priv->engine.lock);
priv->callbacks = callbacks;
priv->user_data = user_data;
priv->engine.loop = g_main_loop_new (NULL, TRUE);
fail_unless (priv->engine.loop != NULL);
GST_TEST_LOCK (priv);
priv->engine.pipeline = gst_pipeline_new ("pipeline");
fail_unless (priv->engine.pipeline != NULL);
GST_DEBUG ("created pipeline %" GST_PTR_FORMAT, priv->engine.pipeline);
/* register a callback to listen for error messages */
bus = gst_pipeline_get_bus (GST_PIPELINE (priv->engine.pipeline));
gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
g_signal_connect (bus, "message::error",
G_CALLBACK (on_ErrorMessageOnBus), priv);
manifest_source =
gst_element_make_from_uri (GST_URI_SRC, manifest_uri, NULL, NULL);
fail_unless (manifest_source != NULL);
priv->engine.manifest_source = manifest_source;
demux = gst_check_setup_element (element_name);
fail_unless (demux != NULL);
priv->engine.demux = demux;
GST_DEBUG ("created demux %" GST_PTR_FORMAT, demux);
g_signal_connect (demux, "element-added", G_CALLBACK (on_demuxElementAdded),
priv);
g_signal_connect (demux, "pad-added", G_CALLBACK (on_demuxNewPad), priv);
g_signal_connect (demux, "pad-removed",
G_CALLBACK (on_demuxPadRemoved), priv);
gst_bin_add_many (GST_BIN (priv->engine.pipeline), manifest_source, demux,
NULL);
ASSERT_OBJECT_REFCOUNT (manifest_source, element_name, 1);
ASSERT_OBJECT_REFCOUNT (demux, element_name, 1);
ret = gst_element_link (manifest_source, demux);
fail_unless_equals_int (ret, TRUE);
priv->engine.clock = gst_system_clock_obtain ();
if (GST_IS_TEST_CLOCK (priv->engine.clock)) {
/*
* live tests will want to manipulate the clock, so they will register a
* gst_test_clock as the system clock.
* The on demand tests do not care about the clock, so they will let the
* system clock to the default one.
* If a gst_test_clock was installed as system clock, we register a
* periodic callback to update its value.
*/
priv->clock_update_id =
g_timeout_add (100, gst_adaptive_demux_update_test_clock, priv);
}
/* call a test callback before we start the pipeline */
if (callbacks->pre_test)
(*callbacks->pre_test) (&priv->engine, priv->user_data);
GST_TEST_UNLOCK (priv);
GST_DEBUG ("Starting pipeline");
stateChange = gst_element_set_state (priv->engine.pipeline, GST_STATE_PAUSED);
fail_unless (stateChange != GST_STATE_CHANGE_FAILURE);
/* wait for completion of the move to PAUSED */
stateChange = gst_element_get_state (priv->engine.pipeline, NULL, NULL,
GST_CLOCK_TIME_NONE);
fail_unless (stateChange != GST_STATE_CHANGE_FAILURE);
g_idle_add ((GSourceFunc) start_pipeline_playing, priv);
/* block until a callback calls g_main_loop_quit (engine.loop) */
GST_DEBUG ("main thread waiting for streams to finish");
g_main_loop_run (priv->engine.loop);
GST_DEBUG ("main thread finished. Stopping pipeline");
/* no need to use gst_element_get_state as the move the GST_STATE_NULL
is always synchronous */
stateChange = gst_element_set_state (priv->engine.pipeline, GST_STATE_NULL);
fail_unless (stateChange != GST_STATE_CHANGE_FAILURE);
GST_TEST_LOCK (priv);
/* call a test callback after the stop of the pipeline */
if (callbacks->post_test)
(*callbacks->post_test) (&priv->engine, priv->user_data);
g_signal_handlers_disconnect_by_func (bus,
G_CALLBACK (on_ErrorMessageOnBus), priv);
gst_bus_remove_signal_watch (bus);
g_signal_handlers_disconnect_by_func (demux, G_CALLBACK (on_demuxNewPad),
priv);
g_signal_handlers_disconnect_by_func (demux, G_CALLBACK (on_demuxPadRemoved),
priv);
GST_DEBUG ("main thread pipeline stopped");
if (priv->clock_update_id != 0)
g_source_remove (priv->clock_update_id);
gst_object_unref (priv->engine.clock);
gst_object_unref (priv->engine.pipeline);
priv->engine.pipeline = NULL;
g_main_loop_unref (priv->engine.loop);
g_ptr_array_unref (priv->engine.output_streams);
gst_object_unref (bus);
GST_TEST_UNLOCK (priv);
g_mutex_clear (&priv->engine.lock);
g_slice_free (GstAdaptiveDemuxTestEnginePrivate, priv);
}
GST_END_TEST
GST_START_TEST (connect_chain_of_elements)
{
gchar *padname = NULL;
KmsConnectData *data1, *data2;
gchar *filter_factory;
GstBus *bus;
loop = g_main_loop_new (NULL, TRUE);
pipeline = gst_pipeline_new (__FUNCTION__);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
data1 = kms_connect_data_create (0);
data2 = kms_connect_data_create (MAX_CHECKS);
data2->data_probe = (KmsProbeType) data_probe_cb;
data2->audio_probe = (KmsProbeType) audio_probe_cb;
data2->video_probe = (KmsProbeType) video_probe_cb;
gst_element_set_state (pipeline, GST_STATE_PLAYING);
data1->src = gst_element_factory_make ("dummysrc", NULL);
data1->sink = gst_element_factory_make ("filterelement", NULL);
data2->src = data1->sink;
data2->sink = gst_element_factory_make ("dummysink", NULL);
g_signal_connect (data1->src, "pad-added", G_CALLBACK (src_pads_added),
data1);
g_signal_connect (data1->sink, "pad-added", G_CALLBACK (sink_pads_added),
data1);
g_signal_connect (data2->src, "pad-added", G_CALLBACK (src_pads_added),
data2);
g_signal_connect (data2->sink, "pad-added", G_CALLBACK (sink_pads_added),
data2);
g_signal_connect (data2->sink, "pad-removed", G_CALLBACK (sink_pads_removed),
data2);
gst_bin_add_many (GST_BIN (pipeline), data1->src, data1->sink, data2->sink,
NULL);
/*******************************/
/* Connect dummysrc to filter */
/*******************************/
/* request src pad using action */
g_signal_emit_by_name (data1->src, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_VIDEO, NULL, GST_PAD_SRC, &data1->video_src);
fail_if (data1->video_src == NULL);
g_signal_emit_by_name (data1->src, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_AUDIO, NULL, GST_PAD_SRC, &data1->audio_src);
fail_if (data1->audio_src == NULL);
g_signal_emit_by_name (data1->src, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_DATA, NULL, GST_PAD_SRC, &data1->data_src);
fail_if (data1->data_src == NULL);
GST_DEBUG ("Video pad name %s", data1->video_src);
GST_DEBUG ("Audio pad name %s", data1->audio_src);
GST_DEBUG ("Data pad name %s", data1->data_src);
filter_factory = "videoflip";
GST_DEBUG ("Setting property uri to : %s", filter_factory);
g_object_set (G_OBJECT (data1->sink), "filter_factory", filter_factory, NULL);
g_object_set (G_OBJECT (data1->src), "video", TRUE, "audio", TRUE, "data",
TRUE, NULL);
/*******************************/
/* Connect filter to dummysink */
/*******************************/
/* request src pad using action */
g_signal_emit_by_name (data2->src, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_VIDEO, NULL, GST_PAD_SRC, &data2->video_src);
fail_if (data2->video_src == NULL);
g_signal_emit_by_name (data2->src, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_AUDIO, NULL, GST_PAD_SRC, &data2->audio_src);
fail_if (data2->audio_src == NULL);
g_signal_emit_by_name (data2->src, "request-new-pad",
KMS_ELEMENT_PAD_TYPE_DATA, NULL, GST_PAD_SRC, &data2->data_src);
fail_if (data2->data_src == NULL);
GST_DEBUG ("Video pad name %s", data2->video_src);
GST_DEBUG ("Audio pad name %s", data2->audio_src);
GST_DEBUG ("Data pad name %s", data2->data_src);
g_object_set (G_OBJECT (data2->sink), "video", TRUE, "audio", TRUE, "data",
TRUE, NULL);
g_timeout_add_seconds (4, print_timedout_pipeline, NULL);
gst_element_sync_state_with_parent (data1->src);
gst_element_sync_state_with_parent (data1->sink);
gst_element_sync_state_with_parent (data2->sink);
g_main_loop_run (loop);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_object_unref (pipeline);
g_free (padname);
g_main_loop_unref (loop);
kms_connect_data_destroy (data1);
kms_connect_data_destroy (data2);
}
static void
test_audio_sendrecv (const gchar * audio_enc_name,
GstStaticCaps expected_caps, gchar * codec)
{
GArray *codecs_array;
gchar *codecs[] = { codec, NULL };
HandOffData *hod;
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
GstSDPMessage *offer, *answer;
GstElement *pipeline = gst_pipeline_new (NULL);
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
GstElement *audiotestsrc_offerer =
gst_element_factory_make ("audiotestsrc", NULL);
GstElement *audiotestsrc_answerer =
gst_element_factory_make ("audiotestsrc", NULL);
GstElement *audio_enc_offerer =
gst_element_factory_make (audio_enc_name, NULL);
GstElement *audio_enc_answerer =
gst_element_factory_make (audio_enc_name, NULL);
GstElement *rtpendpoint_offerer =
gst_element_factory_make ("rtpendpoint", NULL);
GstElement *rtpendpoint_answerer =
gst_element_factory_make ("rtpendpoint", NULL);
GstElement *fakesink_offerer = gst_element_factory_make ("fakesink", NULL);
GstElement *fakesink_answerer = gst_element_factory_make ("fakesink", NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_msg), pipeline);
codecs_array = create_codecs_array (codecs);
g_object_set (rtpendpoint_offerer, "num-audio-medias", 1, "audio-codecs",
g_array_ref (codecs_array), NULL);
g_object_set (rtpendpoint_answerer, "num-audio-medias", 1, "audio-codecs",
g_array_ref (codecs_array), NULL);
g_array_unref (codecs_array);
hod = g_slice_new (HandOffData);
hod->expected_caps = expected_caps;
hod->loop = loop;
g_object_set (G_OBJECT (fakesink_offerer), "signal-handoffs", TRUE, NULL);
g_signal_connect (G_OBJECT (fakesink_offerer), "handoff",
G_CALLBACK (sendrecv_offerer_fakesink_hand_off), hod);
g_object_set (G_OBJECT (fakesink_answerer), "signal-handoffs", TRUE, NULL);
g_signal_connect (G_OBJECT (fakesink_answerer), "handoff",
G_CALLBACK (sendrecv_answerer_fakesink_hand_off), hod);
/* Add elements */
gst_bin_add (GST_BIN (pipeline), rtpendpoint_offerer);
connect_sink_async (rtpendpoint_offerer, audiotestsrc_offerer,
audio_enc_offerer, NULL, pipeline, "sink_audio");
gst_bin_add (GST_BIN (pipeline), rtpendpoint_answerer);
connect_sink_async (rtpendpoint_answerer, audiotestsrc_answerer,
audio_enc_answerer, NULL, pipeline, "sink_audio");
gst_element_set_state (pipeline, GST_STATE_PLAYING);
/* SDP negotiation */
mark_point ();
g_signal_emit_by_name (rtpendpoint_offerer, "generate-offer", &offer);
fail_unless (offer != NULL);
mark_point ();
g_signal_emit_by_name (rtpendpoint_answerer, "process-offer", offer, &answer);
fail_unless (answer != NULL);
mark_point ();
g_signal_emit_by_name (rtpendpoint_offerer, "process-answer", answer);
gst_sdp_message_free (offer);
gst_sdp_message_free (answer);
gst_bin_add (GST_BIN (pipeline), fakesink_offerer);
g_object_set_data (G_OBJECT (rtpendpoint_offerer), AUDIO_SINK,
fakesink_offerer);
g_signal_connect (rtpendpoint_offerer, "pad-added",
G_CALLBACK (connect_sink_on_srcpad_added), NULL);
fail_unless (kms_element_request_srcpad (rtpendpoint_offerer,
KMS_ELEMENT_PAD_TYPE_AUDIO));
gst_bin_add (GST_BIN (pipeline), fakesink_answerer);
g_object_set_data (G_OBJECT (rtpendpoint_answerer), AUDIO_SINK,
fakesink_answerer);
g_signal_connect (rtpendpoint_answerer, "pad-added",
G_CALLBACK (connect_sink_on_srcpad_added), NULL);
fail_unless (kms_element_request_srcpad (rtpendpoint_answerer,
KMS_ELEMENT_PAD_TYPE_AUDIO));
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "test_audio_sendrecv_before_entering_loop");
mark_point ();
g_main_loop_run (loop);
mark_point ();
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "test_audio_sendrecv_end");
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_remove_signal_watch (bus);
g_object_unref (bus);
g_main_loop_unref (loop);
g_object_unref (pipeline);
g_slice_free (HandOffData, hod);
}
