static void test_destruction()
{
OwrBus *bus;
OwrMessageOrigin *origin;
OwrMessageOrigin *origin2;
GPtrArray *buses;
GAsyncQueue *queue;
bus = owr_bus_new();
origin = mock_origin_new();
queue = g_async_queue_new();
mock_origin_assert_bus_table_size(origin, 0);
owr_bus_add_message_origin(bus, origin);
mock_origin_assert_bus_table_size(origin, 1);
owr_bus_set_message_callback(bus, on_message, queue, (GDestroyNotify) g_async_queue_unref);
OWR_POST_EVENT(origin, TEST, NULL);
expect_message_received(queue, OWR_EVENT_TYPE_TEST);
g_assert(1 == g_hash_table_size(MOCK_ORIGIN(origin)->bus_set->table));
OWR_POST_EVENT(origin, TEST, NULL);
mock_origin_assert_bus_table_size(origin, 1);
g_object_unref(bus);
mock_origin_assert_bus_table_size(origin, 1);
OWR_POST_EVENT(origin, TEST, NULL);
mock_origin_assert_bus_table_size(origin, 0);
origin2 = mock_origin_new();
mock_origin_assert_bus_table_size(origin2, 0);
buses = create_buses(10);
g_ptr_array_foreach(buses, (GFunc) owr_bus_add_message_origin, origin);
g_ptr_array_foreach(buses, (GFunc) owr_bus_add_message_origin, origin2);
mock_origin_assert_bus_table_size(origin, 10);
mock_origin_assert_bus_table_size(origin2, 10);
g_ptr_array_unref(buses);
mock_origin_assert_bus_table_size(origin, 10);
mock_origin_assert_bus_table_size(origin2, 10);
OWR_POST_EVENT(origin, TEST, NULL);
mock_origin_assert_bus_table_size(origin, 0);
mock_origin_assert_bus_table_size(origin2, 10);
OWR_POST_EVENT(origin2, TEST, NULL);
mock_origin_assert_bus_table_size(origin2, 0);
}
static void test_message_type_mask()
{
OwrBus *bus;
OwrMessageOrigin *origin;
GAsyncQueue *queue;
bus = owr_bus_new();
origin = mock_origin_new();
g_assert(MOCK_ORIGIN(origin)->bus_set);
g_assert(MOCK_ORIGIN(origin)->bus_set == owr_message_origin_get_bus_set(origin));
owr_bus_add_message_origin(bus, origin);
queue = g_async_queue_new();
owr_bus_set_message_callback(bus, on_message, queue, (GDestroyNotify) g_async_queue_unref);
OWR_POST_ERROR(origin, TEST, NULL);
OWR_POST_STATS(origin, TEST, NULL);
OWR_POST_EVENT(origin, TEST, NULL);
expect_message_received(queue, OWR_ERROR_TYPE_TEST);
expect_message_received(queue, OWR_STATS_TYPE_TEST);
expect_message_received(queue, OWR_EVENT_TYPE_TEST);
g_object_set(bus, "message-type-mask", OWR_MESSAGE_TYPE_EVENT, NULL);
OWR_POST_ERROR(origin, TEST, NULL);
OWR_POST_STATS(origin, TEST, NULL);
OWR_POST_EVENT(origin, TEST, NULL);
expect_message_received(queue, OWR_EVENT_TYPE_TEST);
g_object_set(bus, "message-type-mask", OWR_MESSAGE_TYPE_STATS, NULL);
owr_message_origin_post_message(origin, OWR_MESSAGE_TYPE_ERROR, OWR_ERROR_TYPE_TEST, NULL);
owr_message_origin_post_message(origin, OWR_MESSAGE_TYPE_STATS, OWR_STATS_TYPE_TEST, NULL);
owr_message_origin_post_message(origin, OWR_MESSAGE_TYPE_EVENT, OWR_EVENT_TYPE_TEST, NULL);
expect_message_received(queue, OWR_STATS_TYPE_TEST);
g_object_unref(origin);
g_object_unref(bus);
}
static gboolean set_source(GHashTable *args)
{
OwrMediaRenderer *renderer;
OwrMediaSource *source;
OwrMediaRendererPrivate *priv;
g_return_val_if_fail(args, G_SOURCE_REMOVE);
renderer = g_hash_table_lookup(args, "renderer");
source = g_hash_table_lookup(args, "source");
g_return_val_if_fail(OWR_IS_MEDIA_RENDERER(renderer), G_SOURCE_REMOVE);
g_return_val_if_fail(!source || OWR_IS_MEDIA_SOURCE(source), G_SOURCE_REMOVE);
priv = renderer->priv;
g_mutex_lock(&priv->media_renderer_lock);
if (source == priv->source) {
g_mutex_unlock(&priv->media_renderer_lock);
goto end;
}
if (priv->source) {
_owr_media_source_release_source(priv->source, priv->src);
gst_element_set_state(priv->src, GST_STATE_NULL);
gst_bin_remove(GST_BIN(priv->pipeline), priv->src);
priv->src = NULL;
g_object_unref(priv->source);
priv->source = NULL;
}
if (!source) {
/* Shut down the pipeline if we have no source */
gst_element_set_state(priv->pipeline, GST_STATE_NULL);
OWR_POST_EVENT(renderer, RENDERER_STOPPED, NULL);
g_mutex_unlock(&priv->media_renderer_lock);
goto end;
}
priv->source = g_object_ref(source);
_owr_media_renderer_reconfigure_element(renderer);
maybe_start_renderer(renderer);
g_mutex_unlock(&priv->media_renderer_lock);
end:
g_object_unref(renderer);
if (source)
g_object_unref(source);
g_hash_table_unref(args);
return G_SOURCE_REMOVE;
}
static gboolean shutdown_media_source(GHashTable *args)
{
OwrMediaSource *media_source;
GstElement *source_pipeline, *source_tee;
GHashTable *event_data;
GValue *value;
event_data = _owr_value_table_new();
value = _owr_value_table_add(event_data, "start_time", G_TYPE_INT64);
g_value_set_int64(value, g_get_monotonic_time());
media_source = g_hash_table_lookup(args, "media_source");
g_assert(media_source);
source_pipeline = _owr_media_source_get_source_bin(media_source);
if (!source_pipeline) {
g_object_unref(media_source);
g_hash_table_unref(args);
return FALSE;
}
source_tee = _owr_media_source_get_source_tee(media_source);
if (!source_tee) {
gst_object_unref(source_pipeline);
g_object_unref(media_source);
g_hash_table_unref(args);
return FALSE;
}
if (source_tee->numsrcpads) {
gst_object_unref(source_pipeline);
gst_object_unref(source_tee);
g_object_unref(media_source);
g_hash_table_unref(args);
return FALSE;
}
_owr_media_source_set_source_bin(media_source, NULL);
_owr_media_source_set_source_tee(media_source, NULL);
gst_element_set_state(source_pipeline, GST_STATE_NULL);
gst_object_unref(source_pipeline);
gst_object_unref(source_tee);
value = _owr_value_table_add(event_data, "end_time", G_TYPE_INT64);
g_value_set_int64(value, g_get_monotonic_time());
OWR_POST_EVENT(media_source, LOCAL_SOURCE_STOPPED, event_data);
g_object_unref(media_source);
g_hash_table_unref(args);
return FALSE;
}
static void maybe_start_renderer(OwrMediaRenderer *renderer)
{
OwrMediaRendererPrivate *priv;
GstPad *sinkpad, *srcpad;
GstElement *src;
GstCaps *caps;
GstPadLinkReturn pad_link_return;
priv = renderer->priv;
if (!priv->sink || !priv->source)
return;
sinkpad = gst_element_get_static_pad(priv->sink, "sink");
g_assert(sinkpad);
g_signal_connect(sinkpad, "notify::caps", G_CALLBACK(on_caps), renderer);
caps = OWR_MEDIA_RENDERER_GET_CLASS(renderer)->get_caps(renderer);
src = _owr_media_source_request_source(priv->source, caps);
gst_caps_unref(caps);
g_assert(src);
srcpad = gst_element_get_static_pad(src, "src");
g_assert(srcpad);
priv->src = src;
/* The sink is always inside the bin already */
gst_bin_add_many(GST_BIN(priv->pipeline), priv->src, NULL);
pad_link_return = gst_pad_link(srcpad, sinkpad);
gst_object_unref(sinkpad);
gst_object_unref(srcpad);
if (pad_link_return != GST_PAD_LINK_OK) {
GST_ERROR("Failed to link source with renderer (%d)", pad_link_return);
return;
}
gst_element_set_state(priv->pipeline, GST_STATE_PLAYING);
OWR_POST_EVENT(renderer, RENDERER_STARTED, NULL);
}
/*
* owr_local_media_source_get_pad
*
* The beginning of a media source chain in the pipeline looks like this:
* +------------+
* /---+ inter*sink |
* +--------+ +--------+ +------------+ +-----+ / +------------+
* | source +----+ scale? +---+ capsfilter +---+ tee +---/
* +--------+ +--------+ +------------+ +-----+ \
* \ +------------+
* \---+ inter*sink |
* +------------+
*
* For each newly requested pad a new inter*sink is added to the tee.
* Note that this is a completely independent pipeline, and the complete
* pipeline is only created once for a specific media source.
*
* Then for each newly requested pad another bin with a inter*src is
* created, which is then going to be part of the transport agent
* pipeline. The ghostpad of it is what we return here.
*
* +-----------+ +-------------------------------+ +----------+
* | inter*src +---+ converters/queues/capsfilters +---+ ghostpad |
* +-----------+ +-------------------------------+ +----------+
*
*/
static GstElement *owr_local_media_source_request_source(OwrMediaSource *media_source, GstCaps *caps)
{
OwrLocalMediaSource *local_source;
OwrLocalMediaSourcePrivate *priv;
GstElement *source_element = NULL;
GstElement *source_pipeline;
GHashTable *event_data;
GValue *value;
#if defined(__linux__) && !defined(__ANDROID__)
gchar *tmp;
#endif
g_assert(media_source);
local_source = OWR_LOCAL_MEDIA_SOURCE(media_source);
priv = local_source->priv;
/* only create the source bin for this media source once */
if ((source_pipeline = _owr_media_source_get_source_bin(media_source)))
GST_DEBUG_OBJECT(media_source, "Re-using existing source element/bin");
else {
OwrMediaType media_type = OWR_MEDIA_TYPE_UNKNOWN;
OwrSourceType source_type = OWR_SOURCE_TYPE_UNKNOWN;
GstElement *source, *source_process = NULL, *capsfilter = NULL, *tee;
GstPad *sinkpad, *source_pad;
GEnumClass *media_enum_class, *source_enum_class;
GEnumValue *media_enum_value, *source_enum_value;
gchar *bin_name;
GstCaps *source_caps;
GstBus *bus;
GSource *bus_source;
event_data = _owr_value_table_new();
value = _owr_value_table_add(event_data, "start_time", G_TYPE_INT64);
g_value_set_int64(value, g_get_monotonic_time());
g_object_get(media_source, "media-type", &media_type, "type", &source_type, NULL);
media_enum_class = G_ENUM_CLASS(g_type_class_ref(OWR_TYPE_MEDIA_TYPE));
source_enum_class = G_ENUM_CLASS(g_type_class_ref(OWR_TYPE_SOURCE_TYPE));
media_enum_value = g_enum_get_value(media_enum_class, media_type);
source_enum_value = g_enum_get_value(source_enum_class, source_type);
bin_name = g_strdup_printf("local-%s-%s-source-bin-%u",
media_enum_value ? media_enum_value->value_nick : "unknown",
source_enum_value ? source_enum_value->value_nick : "unknown",
g_atomic_int_add(&unique_bin_id, 1));
g_type_class_unref(media_enum_class);
g_type_class_unref(source_enum_class);
source_pipeline = gst_pipeline_new(bin_name);
gst_pipeline_use_clock(GST_PIPELINE(source_pipeline), gst_system_clock_obtain());
gst_element_set_base_time(source_pipeline, _owr_get_base_time());
gst_element_set_start_time(source_pipeline, GST_CLOCK_TIME_NONE);
g_free(bin_name);
bin_name = NULL;
#ifdef OWR_DEBUG
g_signal_connect(source_pipeline, "deep-notify", G_CALLBACK(_owr_deep_notify), NULL);
#endif
bus = gst_pipeline_get_bus(GST_PIPELINE(source_pipeline));
bus_source = gst_bus_create_watch(bus);
g_source_set_callback(bus_source, (GSourceFunc) bus_call, media_source, NULL);
g_source_attach(bus_source, _owr_get_main_context());
g_source_unref(bus_source);
GST_DEBUG_OBJECT(local_source, "media_type: %d, type: %d", media_type, source_type);
if (media_type == OWR_MEDIA_TYPE_UNKNOWN || source_type == OWR_SOURCE_TYPE_UNKNOWN) {
GST_ERROR_OBJECT(local_source,
"Cannot connect source with unknown type or media type to other component");
goto done;
}
switch (media_type) {
case OWR_MEDIA_TYPE_AUDIO:
{
switch (source_type) {
case OWR_SOURCE_TYPE_CAPTURE:
CREATE_ELEMENT(source, AUDIO_SRC, "audio-source");
#if !defined(__APPLE__) || !TARGET_IPHONE_SIMULATOR
/*
Default values for buffer-time and latency-time on android are 200ms and 20ms.
The minimum latency-time that can be used on Android is 20ms, and using
a 40ms buffer-time with a 20ms latency-time causes crackling audio.
So let's just stick with the defaults.
*/
#if !defined(__ANDROID__)
g_object_set(source, "buffer-time", G_GINT64_CONSTANT(40000),
"latency-time", G_GINT64_CONSTANT(10000), NULL);
#endif
if (priv->device_index > -1) {
#ifdef __APPLE__
g_object_set(source, "device", priv->device_index, NULL);
#elif defined(__linux__) && !defined(__ANDROID__)
tmp = g_strdup_printf("%d", priv->device_index);
g_object_set(source, "device", tmp, NULL);
g_free(tmp);
#endif
}
#endif
break;
case OWR_SOURCE_TYPE_TEST:
CREATE_ELEMENT(source, "audiotestsrc", "audio-source");
g_object_set(source, "is-live", TRUE, NULL);
break;
case OWR_SOURCE_TYPE_UNKNOWN:
default:
g_assert_not_reached();
goto done;
}
break;
}
case OWR_MEDIA_TYPE_VIDEO:
{
GstPad *srcpad;
GstCaps *device_caps;
switch (source_type) {
case OWR_SOURCE_TYPE_CAPTURE:
CREATE_ELEMENT(source, VIDEO_SRC, "video-source");
if (priv->device_index > -1) {
#if defined(__APPLE__) && !TARGET_IPHONE_SIMULATOR
g_object_set(source, "device-index", priv->device_index, NULL);
#elif defined(__ANDROID__)
g_object_set(source, "cam-index", priv->device_index, NULL);
#elif defined(__linux__)
tmp = g_strdup_printf("/dev/video%d", priv->device_index);
g_object_set(source, "device", tmp, NULL);
g_free(tmp);
#endif
}
break;
case OWR_SOURCE_TYPE_TEST: {
GstElement *src, *time;
GstPad *srcpad;
source = gst_bin_new("video-source");
CREATE_ELEMENT(src, "videotestsrc", "videotestsrc");
g_object_set(src, "is-live", TRUE, NULL);
gst_bin_add(GST_BIN(source), src);
time = gst_element_factory_make("timeoverlay", "timeoverlay");
if (time) {
g_object_set(time, "font-desc", "Sans 60", NULL);
gst_bin_add(GST_BIN(source), time);
gst_element_link(src, time);
srcpad = gst_element_get_static_pad(time, "src");
} else
srcpad = gst_element_get_static_pad(src, "src");
gst_element_add_pad(source, gst_ghost_pad_new("src", srcpad));
gst_object_unref(srcpad);
break;
}
case OWR_SOURCE_TYPE_UNKNOWN:
default:
g_assert_not_reached();
goto done;
}
/* First try to see if we can just get the format we want directly */
source_caps = gst_caps_new_empty();
#if GST_CHECK_VERSION(1, 5, 0)
gst_caps_foreach(caps, fix_video_caps_framerate, source_caps);
#else
_owr_gst_caps_foreach(caps, fix_video_caps_framerate, source_caps);
#endif
/* Now see what the device can really produce */
srcpad = gst_element_get_static_pad(source, "src");
gst_element_set_state(source, GST_STATE_READY);
device_caps = gst_pad_query_caps(srcpad, source_caps);
if (gst_caps_is_empty(device_caps)) {
/* Let's see if it works when we drop format constraints (which can be dealt with downsteram) */
GstCaps *tmp = source_caps;
source_caps = gst_caps_new_empty();
#if GST_CHECK_VERSION(1, 5, 0)
gst_caps_foreach(tmp, fix_video_caps_format, source_caps);
#else
_owr_gst_caps_foreach(tmp, fix_video_caps_format, source_caps);
#endif
gst_caps_unref(tmp);
gst_caps_unref(device_caps);
device_caps = gst_pad_query_caps(srcpad, source_caps);
if (gst_caps_is_empty(device_caps)) {
/* Accepting any format didn't work, we're going to hope that scaling fixes it */
CREATE_ELEMENT(source_process, "videoscale", "video-source-scale");
gst_bin_add(GST_BIN(source_pipeline), source_process);
}
}
gst_caps_unref(device_caps);
gst_object_unref(srcpad);
#if defined(__APPLE__) && TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
/* Force NV12 on iOS else the source can negotiate BGRA
* ercolorspace can do NV12 -> BGRA and NV12 -> I420 which is what
* is needed for Bowser */
gst_caps_set_simple(source_caps, "format", G_TYPE_STRING, "NV12", NULL);
#endif
CREATE_ELEMENT(capsfilter, "capsfilter", "video-source-capsfilter");
g_object_set(capsfilter, "caps", source_caps, NULL);
gst_caps_unref(source_caps);
gst_bin_add(GST_BIN(source_pipeline), capsfilter);
break;
}
case OWR_MEDIA_TYPE_UNKNOWN:
default:
g_assert_not_reached();
goto done;
}
g_assert(source);
source_pad = gst_element_get_static_pad(source, "src");
g_signal_connect(source_pad, "notify::caps", G_CALLBACK(on_caps), media_source);
gst_object_unref(source_pad);
CREATE_ELEMENT(tee, "tee", "source-tee");
g_object_set(tee, "allow-not-linked", TRUE, NULL);
gst_bin_add_many(GST_BIN(source_pipeline), source, tee, NULL);
/* Many sources don't like reconfiguration and it's pointless
* here anyway right now. No need to reconfigure whenever something
* is added to the tee or removed.
* We will have to implement reconfiguration differently later by
* selecting the best caps based on all consumers.
*/
sinkpad = gst_element_get_static_pad(tee, "sink");
gst_pad_add_probe(sinkpad, GST_PAD_PROBE_TYPE_EVENT_UPSTREAM, drop_reconfigure_event, NULL, NULL);
gst_object_unref(sinkpad);
if (!source)
GST_ERROR_OBJECT(media_source, "Failed to create source element!");
if (capsfilter) {
LINK_ELEMENTS(capsfilter, tee);
if (source_process) {
LINK_ELEMENTS(source_process, capsfilter);
LINK_ELEMENTS(source, source_process);
} else
LINK_ELEMENTS(source, capsfilter);
} else if (source_process) {
LINK_ELEMENTS(source_process, tee);
LINK_ELEMENTS(source, source_process);
} else
LINK_ELEMENTS(source, tee);
gst_element_sync_state_with_parent(tee);
if (capsfilter)
gst_element_sync_state_with_parent(capsfilter);
if (source_process)
gst_element_sync_state_with_parent(source_process);
gst_element_sync_state_with_parent(source);
_owr_media_source_set_source_bin(media_source, source_pipeline);
_owr_media_source_set_source_tee(media_source, tee);
if (gst_element_set_state(source_pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
GST_ERROR("Failed to set local source pipeline %s to playing", GST_OBJECT_NAME(source_pipeline));
/* FIXME: We should handle this and don't expose the source */
}
value = _owr_value_table_add(event_data, "end_time", G_TYPE_INT64);
g_value_set_int64(value, g_get_monotonic_time());
OWR_POST_EVENT(media_source, LOCAL_SOURCE_STARTED, event_data);
g_signal_connect(tee, "pad-removed", G_CALLBACK(tee_pad_removed_cb), media_source);
}
gst_object_unref(source_pipeline);
source_element = OWR_MEDIA_SOURCE_CLASS(owr_local_media_source_parent_class)->request_source(media_source, caps);
done:
return source_element;
}
static void test_refcounting()
{
OwrBus *bus;
OwrMessageOrigin *origin;
GWeakRef weak_ref;
GAsyncQueue *queue;
queue = g_async_queue_new();
bus = owr_bus_new();
owr_bus_set_message_callback(bus, on_message, queue, NULL);
origin = mock_origin_new();
owr_bus_add_message_origin(bus, origin);
g_weak_ref_init(&weak_ref, bus);
OWR_POST_STATS(origin, TEST, NULL);
g_object_unref(bus); /* this should finalize the bus, pending messages should not keep it alive */
assert_weak_ref(&weak_ref, FALSE, __LINE__);
g_weak_ref_clear(&weak_ref);
bus = owr_bus_new();
owr_bus_set_message_callback(bus, on_message, queue, NULL);
owr_bus_add_message_origin(bus, origin);
g_weak_ref_init(&weak_ref, origin);
OWR_POST_STATS(origin, TEST, NULL);
g_object_unref(origin); /* the origin should be kept alive though */
g_object_ref(origin);
assert_weak_ref(&weak_ref, TRUE, __LINE__);
g_object_unref(origin);
g_assert(g_async_queue_timeout_pop(queue, G_USEC_PER_SEC));
g_usleep(1000); /* messages are cleaned up after all callbacks have happened, so wait a bit more */
assert_weak_ref(&weak_ref, FALSE, __LINE__); /* but be cleaned up after the message was handled */
g_weak_ref_clear(&weak_ref);
/* same as previous tests, but with message filter */
origin = mock_origin_new();
owr_bus_add_message_origin(bus, origin);
g_weak_ref_init(&weak_ref, origin);
g_object_set(bus, "message-type-mask", OWR_MESSAGE_TYPE_STATS, NULL);
OWR_POST_STATS(origin, TEST, NULL);
OWR_POST_EVENT(origin, TEST, NULL);
OWR_POST_ERROR(origin, TEST, NULL);
g_object_unref(origin);
g_object_ref(origin);
assert_weak_ref(&weak_ref, TRUE, __LINE__);
g_object_unref(origin);
g_assert(g_async_queue_timeout_pop(queue, G_USEC_PER_SEC));
g_usleep(1000);
assert_weak_ref(&weak_ref, FALSE, __LINE__);
g_weak_ref_clear(&weak_ref);
origin = mock_origin_new();
owr_bus_add_message_origin(bus, origin);
g_weak_ref_init(&weak_ref, bus);
OWR_POST_STATS(origin, TEST, NULL);
OWR_POST_EVENT(origin, TEST, NULL);
OWR_POST_ERROR(origin, TEST, NULL);
g_object_unref(bus);
assert_weak_ref(&weak_ref, FALSE, __LINE__);
g_weak_ref_clear(&weak_ref);
}
static gpointer post_message_thread_func(OwrMessageOrigin *origin)
{
OWR_POST_EVENT(origin, TEST, NULL);
return NULL;
}
static void post_messages(OwrMessageOrigin *origin, gpointer user_data)
{
OWR_UNUSED(user_data);
OWR_POST_EVENT(origin, TEST, NULL);
}
