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); }