struct SimpleTestStream * simple_conference_add_stream ( struct SimpleTestConference *dat, struct SimpleTestConference *target, const gchar *transmitter, guint st_param_count, GParameter *st_params) { struct SimpleTestStream *st = g_new0 (struct SimpleTestStream, 1); GError *error = NULL; st->dat = dat; st->target = target; st->participant = fs_conference_new_participant ( FS_CONFERENCE (dat->conference), &error); if (error) fail ("Error while creating new participant (%d): %s", error->code, error->message); fail_if (st->participant == NULL, "Could not make participant, but no GError!"); st->stream = fs_session_new_stream (dat->session, st->participant, FS_DIRECTION_BOTH, &error); if (error) fail ("Error while creating new stream (%d): %s", error->code, error->message); fail_if (st->stream == NULL, "Could not make stream, but no GError!"); fail_unless (fs_stream_set_transmitter (st->stream, transmitter, st_params, st_param_count, &error)); fail_unless (error == NULL); g_object_set_data (G_OBJECT (st->stream), "SimpleTestStream", st); dat->streams = g_list_append (dat->streams, st); return st; }
struct SimpleMsnConference * setup_conference (FsStreamDirection dir, struct SimpleMsnConference *target) { struct SimpleMsnConference *dat = g_new0 (struct SimpleMsnConference, 1); GError *error = NULL; GstBus *bus; GParameter param = {NULL, {0}}; gint n_params = 0; guint tos; dat->target = target; dat->direction = dir; dat->pipeline = gst_pipeline_new (NULL); bus = gst_element_get_bus (dat->pipeline); gst_bus_add_watch (bus, bus_watch, dat); gst_object_unref (bus); if (dir == FS_DIRECTION_SEND) dat->conf = FS_CONFERENCE ( gst_element_factory_make ("fsmsncamsendconference", NULL)); else dat->conf = FS_CONFERENCE ( gst_element_factory_make ("fsmsncamrecvconference", NULL)); ts_fail_unless (dat->conf != NULL); ts_fail_unless (gst_bin_add (GST_BIN (dat->pipeline), GST_ELEMENT (dat->conf))); dat->part = fs_conference_new_participant (dat->conf, &error); ts_fail_unless (error == NULL, "Error: %s", error ? error->message: ""); ts_fail_unless (dat->part != NULL); dat->session = fs_conference_new_session (dat->conf, FS_MEDIA_TYPE_VIDEO, &error); ts_fail_unless (dat->session != NULL, "Session create error: %s:", error ? error->message : "No GError"); ts_fail_unless (error == NULL); g_object_set (dat->session, "tos", 2, NULL); g_object_get (dat->session, "tos", &tos, NULL); ts_fail_unless (tos == 2); if (dir == FS_DIRECTION_SEND) { GstPad *sinkpad, *srcpad; GstElement *src; src = gst_element_factory_make ("videotestsrc", NULL); ts_fail_unless (src != NULL); g_object_set (src, "is-live", TRUE, NULL); ts_fail_unless (gst_bin_add (GST_BIN (dat->pipeline), GST_ELEMENT (src))); g_object_get (dat->session, "sink-pad", &sinkpad, NULL); ts_fail_if (sinkpad == NULL); srcpad = gst_element_get_static_pad (src, "src"); ts_fail_if (srcpad == NULL); ts_fail_if (GST_PAD_LINK_FAILED (gst_pad_link ( srcpad, sinkpad))); gst_object_unref (srcpad); gst_object_unref (sinkpad); } if (target) { guint session_id = 0; n_params = 1; g_object_get (target->stream, "session-id", &session_id, NULL); ts_fail_unless (session_id >= 9000 && session_id < 10000); param.name = "session-id"; g_value_init (¶m.value, G_TYPE_UINT); g_value_set_uint (¶m.value, session_id); } dat->stream = fs_session_new_stream (dat->session, dat->part, dir, &error); ts_fail_unless (dat->stream != NULL); ts_fail_unless (error == NULL); fail_unless (fs_stream_set_transmitter (dat->stream, NULL, ¶m, n_params, &error)); fail_unless (error == NULL); g_signal_connect (dat->stream, "src-pad-added", G_CALLBACK (stream_src_pad_added), dat); ts_fail_if (gst_element_set_state (dat->pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE); return dat; }
static TestSession* add_audio_session (GstElement *pipeline, FsConference *conf, guint id, FsParticipant *part, gchar *send_socket, gchar *recv_socket) { TestSession *ses = g_slice_new0 (TestSession); GError *error = NULL; GstPad *pad = NULL, *pad2 = NULL; GstElement *src = NULL; GList *cands = NULL; GParameter param = {0}; gboolean res; FsCandidate *cand; GList *codecs = NULL; ses->send_socket = send_socket; ses->recv_socket = recv_socket; ses->session = fs_conference_new_session (conf, FS_MEDIA_TYPE_AUDIO, &error); print_error (error); g_assert (ses->session); g_object_get (ses->session, "sink-pad", &pad, NULL); if (g_getenv ("AUDIOSRC")) src = gst_parse_bin_from_description (g_getenv ("AUDIOSRC"), TRUE, &error); else src = gst_parse_bin_from_description (DEFAULT_AUDIOSRC, TRUE, &error); print_error (error); g_assert (src); g_assert (gst_bin_add (GST_BIN (pipeline), src)); pad2 = gst_element_get_static_pad (src, "src"); g_assert (pad2); g_assert (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (pad2, pad))); gst_object_unref (pad2); gst_object_unref (pad); ses->stream = fs_session_new_stream (ses->session, part, FS_DIRECTION_BOTH, &error); print_error (error); g_assert (ses->stream); cand = fs_candidate_new ("", FS_COMPONENT_RTP, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, send_socket, 0); cands = g_list_prepend (NULL, cand); param.name = "preferred-local-candidates"; g_value_init (¶m.value, FS_TYPE_CANDIDATE_LIST); g_value_take_boxed (¶m.value, cands); res = fs_stream_set_transmitter (ses->stream, "shm", ¶m, 1, &error); print_error (error); g_value_unset (¶m.value); g_signal_connect (ses->stream, "src-pad-added", G_CALLBACK (src_pad_added_cb), pipeline); codecs = g_list_prepend (NULL, fs_codec_new (FS_CODEC_ID_ANY, "PCMA", FS_MEDIA_TYPE_AUDIO, 0)); codecs = g_list_prepend (codecs, fs_codec_new (FS_CODEC_ID_ANY, "PCMU", FS_MEDIA_TYPE_AUDIO, 0)); res = fs_session_set_codec_preferences (ses->session, codecs, &error); print_error (error); fs_codec_list_destroy (codecs); g_object_get (ses->session, "codecs-without-config", &codecs, NULL); res = fs_stream_set_remote_codecs (ses->stream, codecs, &error); print_error (error); g_assert (res); return ses; }
/** * fs_stream_set_transmitter_ht: * @stream: a #FsStream * @transmitter: Name of the type of transmitter to use for this stream * @stream_transmitter_parameters: (element-type utf8 GValue) (allow-none): * A #GHashTable of string->GValue containing the parameters. * @error: location of a #GError, or %NULL if no error occured * * Set the transmitter to use for this stream. This function will only succeed * once. * * The parameters correspond to the varios GObject properties of the * selected stream transmitter. * * This is the same as fs_stream_set_transmitter() except that the parameters * are passed in a #GHashTable to make it more friendly to GObject introspection * * Returns: %TRUE if the transmitter could be set, %FALSE otherwise */ gboolean fs_stream_set_transmitter_ht (FsStream *stream, const gchar *transmitter, GHashTable *stream_transmitter_parameters, GError **error) { GParameter *params = NULL; gboolean ret = FALSE; guint n_params = 0; guint i = 0; if (stream_transmitter_parameters && g_hash_table_size (stream_transmitter_parameters) != 0) { FsSession *session = NULL; GType st_type; GObjectClass *st_class = NULL; GHashTableIter iter; gpointer key, value; n_params = g_hash_table_size (stream_transmitter_parameters); g_object_get (stream, "session", &session, NULL); if (!session) { g_set_error_literal (error, FS_ERROR, FS_ERROR_DISPOSED, "Stream has already been disposed"); return FALSE; } st_type = fs_session_get_stream_transmitter_type (session, transmitter); g_object_unref (session); if (st_type == 0) { g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS, "Unknown transmitter: %s", transmitter); return FALSE; } params = g_new0 (GParameter, n_params); st_class = g_type_class_ref (st_type); g_hash_table_iter_init (&iter, stream_transmitter_parameters); while (g_hash_table_iter_next (&iter, &key, &value)) { GParamSpec *spec; gchar *name = key; const GValue *v = value; spec = g_object_class_find_property (st_class, name); if (!spec) { g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS, "Unknown argument %s for transmitter %s", name, transmitter); goto end; } params[i].name = name; g_value_init (¶ms[i].value, G_PARAM_SPEC_VALUE_TYPE(spec)); if (!g_value_transform (v, ¶ms[i].value)) { g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS, "Invalid type of argument %s for transmitter %s", name, transmitter); goto end; } i++; } } ret = fs_stream_set_transmitter (stream, transmitter, params, n_params, error); end: for (i = 0; i < n_params; i++) g_value_unset (¶ms[i].value); g_free (params); return ret; }