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