static void
fs_participant_finalize (GObject *object)
{
FsParticipant *self = FS_PARTICIPANT (object);
if (self->priv->cname) {
g_free (self->priv->cname);
self->priv->cname = NULL;
}
g_mutex_free (self->mutex);
G_OBJECT_CLASS (fs_participant_parent_class)->finalize (object);
}
static void
fs_participant_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
FsParticipant *self = FS_PARTICIPANT (object);
switch (prop_id) {
case PROP_CNAME:
self->priv->cname = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
fs_rtp_stream_set_transmitter (FsStream *stream,
const gchar *transmitter,
GParameter *stream_transmitter_parameters,
guint stream_transmitter_n_parameters,
GError **error)
{
FsStreamTransmitter *st = NULL;
FsRtpStream *self = FS_RTP_STREAM (stream);
FsRtpSession *session = fs_rtp_stream_get_session (self, error);
if (!session)
return FALSE;
FS_RTP_SESSION_LOCK (session);
if (self->priv->stream_transmitter)
{
FS_RTP_SESSION_UNLOCK (session);
g_object_unref (session);
return FALSE;
}
FS_RTP_SESSION_UNLOCK (session);
st = self->priv->get_new_stream_transmitter_cb (self,
FS_PARTICIPANT (self->participant), transmitter,
stream_transmitter_parameters, stream_transmitter_n_parameters, error,
self->priv->user_data_for_cb);
if (!st)
{
g_object_unref (session);
return FALSE;
}
g_object_set (st, "sending",
self->priv->direction & FS_DIRECTION_SEND, NULL);
self->priv->local_candidates_prepared_handler_id =
g_signal_connect_object (st,
"local-candidates-prepared",
G_CALLBACK (_local_candidates_prepared),
self, 0);
self->priv->new_active_candidate_pair_handler_id =
g_signal_connect_object (st,
"new-active-candidate-pair",
G_CALLBACK (_new_active_candidate_pair),
self, 0);
self->priv->new_local_candidate_handler_id =
g_signal_connect_object (st,
"new-local-candidate",
G_CALLBACK (_new_local_candidate),
self, 0);
self->priv->error_handler_id =
g_signal_connect_object (st,
"error",
G_CALLBACK (_transmitter_error),
self, 0);
self->priv->known_source_packet_received_handler_id =
g_signal_connect_object (st,
"known-source-packet-received",
G_CALLBACK (_known_source_packet_received),
self, 0);
self->priv->state_changed_handler_id =
g_signal_connect_object (st,
"state-changed",
G_CALLBACK (_state_changed),
self, 0);
FS_RTP_SESSION_LOCK (session);
self->priv->stream_transmitter = st;
if (self->priv->direction & FS_DIRECTION_SEND)
self->priv->sending_changed_locked_cb (self,
self->priv->direction & FS_DIRECTION_SEND,
self->priv->user_data_for_cb);
FS_RTP_SESSION_UNLOCK (session);
if (!fs_stream_transmitter_gather_local_candidates (st, error))
{
FS_RTP_SESSION_LOCK (session);
self->priv->stream_transmitter = NULL;
FS_RTP_SESSION_UNLOCK (session);
g_object_unref (st);
g_object_unref (session);
return FALSE;
}
g_object_unref (session);
return TRUE;
}
static void
run_nice_transmitter_test (gint n_parameters, GParameter *params,
gint flags)
{
GError *error = NULL;
FsTransmitter *trans = NULL, *trans2 = NULL;
FsStreamTransmitter *st = NULL, *st2 = NULL;
GstBus *bus = NULL;
GstElement *pipeline = NULL;
GstElement *pipeline2 = NULL;
FsNiceTestParticipant *p1 = NULL, *p2 = NULL;
memset (buffer_count, 0, sizeof(gint)*4);
memset (received_known, 0, sizeof(guint)*4);
running = TRUE;
associate_on_source = !(flags & FLAG_NO_SOURCE);
is_address_local = (flags & FLAG_IS_LOCAL);
force_candidates = (flags & FLAG_FORCE_CANDIDATES);
if (flags & FLAG_RECVONLY_FILTER)
ts_fail_unless (fs_fake_filter_register ());
if (flags & FLAG_NOT_SENDING)
{
buffer_count[0][0] = 20;
received_known[0][0] = 20;
buffer_count[1][0] = 20;
received_known[1][0] = 20;
}
loop = g_main_loop_new (NULL, FALSE);
trans = fs_transmitter_new ("nice", 2, 0, &error);
if (error) {
ts_fail ("Error creating transmitter: (%s:%d) %s",
g_quark_to_string (error->domain), error->code, error->message);
}
ts_fail_if (trans == NULL, "No transmitter create, yet error is still NULL");
if (flags & FLAG_RECVONLY_FILTER)
ts_fail_unless (g_signal_connect (trans, "get-recvonly-filter",
G_CALLBACK (_get_recvonly_filter), NULL));
trans2 = fs_transmitter_new ("nice", 2, 0, &error);
if (error) {
ts_fail ("Error creating transmitter: (%s:%d) %s",
g_quark_to_string (error->domain), error->code, error->message);
}
ts_fail_if (trans2 == NULL, "No transmitter create, yet error is still NULL");
if (flags & FLAG_RECVONLY_FILTER)
ts_fail_unless (g_signal_connect (trans2, "get-recvonly-filter",
G_CALLBACK (_get_recvonly_filter), NULL));
pipeline = setup_pipeline (trans, G_CALLBACK (_handoff_handler1));
pipeline2 = setup_pipeline (trans2, G_CALLBACK (_handoff_handler2));
g_object_set_data (G_OBJECT (trans), "pipeline", pipeline);
g_object_set_data (G_OBJECT (trans2), "pipeline", pipeline2);
bus = gst_element_get_bus (pipeline);
gst_bus_add_watch (bus, bus_error_callback, NULL);
gst_object_unref (bus);
bus = gst_element_get_bus (pipeline2);
gst_bus_add_watch (bus, bus_error_callback, NULL);
gst_object_unref (bus);
/*
* I'm passing the participant because any gobject will work,
* but it should be the participant
*/
p1 = g_object_new (fs_nice_test_participant_get_type (), NULL);
p2 = g_object_new (fs_nice_test_participant_get_type (), NULL);
st = fs_transmitter_new_stream_transmitter (trans, FS_PARTICIPANT (p1),
n_parameters, params, &error);
if (error)
ts_fail ("Error creating stream transmitter: (%s:%d) %s",
g_quark_to_string (error->domain), error->code, error->message);
ts_fail_if (st == NULL, "No stream transmitter created, yet error is NULL");
st2 = fs_transmitter_new_stream_transmitter (trans2, FS_PARTICIPANT (p2),
n_parameters, params, &error);
if (error)
ts_fail ("Error creating stream transmitter: (%s:%d) %s",
g_quark_to_string (error->domain), error->code, error->message);
ts_fail_if (st2 == NULL, "No stream transmitter created, yet error is NULL");
g_object_set (st, "sending", !(flags & FLAG_NOT_SENDING), NULL);
g_object_set (st2, "sending", !(flags & FLAG_NOT_SENDING), NULL);
ts_fail_unless (g_signal_connect (st, "new-local-candidate",
G_CALLBACK (_new_local_candidate), st2),
"Could not connect new-local-candidate signal");
ts_fail_unless (g_signal_connect (st, "local-candidates-prepared",
G_CALLBACK (_local_candidates_prepared), st2),
"Could not connect local-candidates-prepared signal");
ts_fail_unless (g_signal_connect (st, "new-active-candidate-pair",
G_CALLBACK (_new_active_candidate_pair), trans),
"Could not connect new-active-candidate-pair signal");
ts_fail_unless (g_signal_connect (st, "error",
G_CALLBACK (stream_transmitter_error), NULL),
"Could not connect error signal");
ts_fail_unless (g_signal_connect (st, "state-changed",
G_CALLBACK (_stream_state_changed), trans),
"Could not connect to state-changed signal");
ts_fail_unless (g_signal_connect (st, "known-source-packet-received",
G_CALLBACK (_known_source_packet_received), GUINT_TO_POINTER (1)),
"Could not connect to known-source-packet-received signal");
ts_fail_unless (g_signal_connect (st2, "new-local-candidate",
G_CALLBACK (_new_local_candidate), st),
"Could not connect new-local-candidate signal");
ts_fail_unless (g_signal_connect (st2, "local-candidates-prepared",
G_CALLBACK (_local_candidates_prepared), st),
"Could not connect local-candidates-prepared signal");
ts_fail_unless (g_signal_connect (st2, "new-active-candidate-pair",
G_CALLBACK (_new_active_candidate_pair), trans2),
"Could not connect new-active-candidate-pair signal");
ts_fail_unless (g_signal_connect (st2, "error",
G_CALLBACK (stream_transmitter_error), NULL),
"Could not connect error signal");
ts_fail_unless (g_signal_connect (st2, "state-changed",
G_CALLBACK (_stream_state_changed), trans2),
"Could not connect to state-changed signal");
ts_fail_unless (g_signal_connect (st2, "known-source-packet-received",
G_CALLBACK (_known_source_packet_received), GUINT_TO_POINTER (2)),
"Could not connect to known-source-packet-received signal");
ts_fail_if (gst_element_set_state (pipeline, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_FAILURE, "Could not set the pipeline to playing");
ts_fail_if (gst_element_set_state (pipeline2, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_FAILURE, "Could not set the pipeline to playing");
if (!fs_stream_transmitter_gather_local_candidates (st, &error))
{
if (error)
ts_fail ("Could not start gathering local candidates %s",
error->message);
else
ts_fail ("Could not start gathering candidates"
" (without a specified error)");
}
if (!fs_stream_transmitter_gather_local_candidates (st2, &error))
{
if (error)
ts_fail ("Could not start gathering local candidates %s",
error->message);
else
ts_fail ("Could not start gathering candidates"
" (without a specified error)");
}
g_idle_add (check_running, NULL);
g_main_loop_run (loop);
fs_stream_transmitter_stop (st);
fs_stream_transmitter_stop (st2);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
gst_element_set_state (pipeline2, GST_STATE_NULL);
gst_element_get_state (pipeline2, NULL, NULL, GST_CLOCK_TIME_NONE);
if (st)
g_object_unref (st);
if (st2)
g_object_unref (st2);
g_object_unref (trans);
g_object_unref (trans2);
g_object_unref (p1);
g_object_unref (p2);
gst_object_unref (pipeline);
g_main_loop_unref (loop);
}
