static void
_handoff_handler (GstElement *element, GstBuffer *buffer, GstPad *pad,
gpointer user_data)
{
gint component_id = GPOINTER_TO_INT (user_data);
ts_fail_unless (gst_buffer_get_size (buffer) == component_id * 10,
"Buffer is size %d but component_id is %d", gst_buffer_get_size (buffer),
component_id);
buffer_count[component_id-1]++;
GST_LOG ("Buffer %d component: %d size: %" G_GSIZE_FORMAT,
buffer_count[component_id-1], component_id, gst_buffer_get_size (buffer));
ts_fail_if (buffer_count[component_id-1] > 20,
"Too many buffers %d > 20 for component",
buffer_count[component_id-1], component_id);
if (buffer_count[0] == 20 && buffer_count[1] == 20) {
/* TEST OVER */
if (associate_on_source)
ts_fail_unless (buffer_count[0] == received_known[0] &&
buffer_count[1] == received_known[1], "Some known buffers from known"
" sources have not been reported (%d != %u || %d != %u)",
buffer_count[0], received_known[0],
buffer_count[1], received_known[1]);
else
ts_fail_unless (received_known[0] == 0 && received_known[1] == 0,
"Got a known-source-packet-received signal when we shouldn't have");
g_atomic_int_set(&running, FALSE);
g_main_loop_quit (loop);
}
}
static void
stream_src_pad_added (FsStream *stream, GstPad *pad, FsCodec *codec,
struct SimpleMsnConference *dat)
{
GstElement *sink = gst_element_factory_make ("fakesink", NULL);
GstPad *sinkpad;
GST_DEBUG ("pad added");
ts_fail_unless (sink != NULL);
ts_fail_unless (gst_bin_add (GST_BIN (dat->pipeline), sink));
sinkpad = gst_element_get_static_pad (sink, "sink");
ts_fail_unless (sinkpad != NULL);
gst_pad_add_buffer_probe (sinkpad, G_CALLBACK (pad_probe_cb), dat);
ts_fail_if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sinkpad)));
gst_object_unref (sinkpad);
ts_fail_if (gst_element_set_state (sink, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_FAILURE);
}
static void
set_initial_codecs (
struct SimpleTestConference *from,
struct SimpleTestStream *to)
{
GList *codecs = NULL;
GList *filtered_codecs = NULL;
GList *item = NULL;
GList *rcodecs2 = NULL;
GError *error = NULL;
g_object_get (from->session, "codecs", &codecs, NULL);
ts_fail_if (codecs == NULL, "Could not get the codecs");
for (item = g_list_first (codecs); item; item = g_list_next (item))
{
FsCodec *codec = item->data;
if (codec->id == 0 || codec->id == 8)
filtered_codecs = g_list_append (filtered_codecs, codec);
}
ts_fail_if (filtered_codecs == NULL, "PCMA and PCMU are not in the codecs"
" you must install gst-plugins-good");
g_debug ("Setting initial remote codecs on %d:%d from %d",
to->dat->id, to->target->id,
from->id);
if (!fs_stream_set_remote_codecs (to->stream, filtered_codecs, &error))
{
if (error)
ts_fail ("Could not set the remote codecs on stream %d:%d (%d): %s",
to->dat->id, to->target->id,
error->code,
error->message);
else
ts_fail ("Could not set the remote codecs on stream %d"
" and we DID not get a GError!!", to->target->id);
}
g_object_get (to->stream, "remote-codecs", &rcodecs2, NULL);
ts_fail_unless (_compare_codec_lists (rcodecs2, filtered_codecs),
"Can not get remote codecs correctly");
fs_codec_list_destroy (rcodecs2);
if (select_last_codec)
ts_fail_unless (
fs_session_set_send_codec (to->dat->session,
g_list_last (filtered_codecs)->data,
&error),
"Error setting the send codec to the last codec: %s",
error ? error->message : "No GError");
g_clear_error (&error);
g_list_free (filtered_codecs);
fs_codec_list_destroy (codecs);
}
static void
_negotiated_codecs_notify (GObject *object, GParamSpec *paramspec,
gpointer user_data)
{
struct SimpleTestConference *dat = user_data;
FsSession *session = FS_SESSION (object);
GList *codecs = NULL;
GError *error = NULL;
GList *item = NULL;
g_debug ("%d: New negotiated codecs", dat->id);
ts_fail_if (session != dat->session, "Got signal from the wrong object");
g_object_get (dat->session, "codecs", &codecs, NULL);
ts_fail_if (codecs == NULL, "Could not get the negotiated codecs");
/* We have to find the stream from the target that points back to us */
for (item = g_list_first (dat->streams); item; item = g_list_next (item))
{
struct SimpleTestStream *st = item->data;
struct SimpleTestStream *st2 = find_pointback_stream (st->target, dat);
GList *rcodecs2;
g_debug ("Setting negotiated remote codecs on %d:%d from %d",st2->dat->id,
st2->target->id, dat->id);
if (!fs_stream_set_remote_codecs (st2->stream, codecs, &error))
{
if (error)
ts_fail ("Could not set the remote codecs on stream %d:%d (%d): %s",
st2->dat->id, st2->target->id,
error->code,
error->message);
else
ts_fail ("Could not set the remote codecs on stream %d:%d"
" and we DID not get a GError!!",
st2->dat->id, st2->target->id);
}
g_object_get (st2->stream, "remote-codecs", &rcodecs2, NULL);
ts_fail_unless (_compare_codec_lists (rcodecs2, codecs),
"Can not get remote codecs correctly");
fs_codec_list_destroy (rcodecs2);
if (select_last_codec)
ts_fail_unless (
fs_session_set_send_codec (st2->dat->session,
g_list_last (codecs)->data,
&error),
"Error setting the send codec to the last codec: %s",
error ? error->message : "No GError");
g_clear_error (&error);
break;
}
fs_codec_list_destroy (codecs);
}
static gboolean
start_stop_sending_dtmf (gpointer data)
{
GstState state;
GstStateChangeReturn ret;
if (!dat || !dat->pipeline || !dat->session)
return TRUE;
ret = gst_element_get_state (dat->pipeline, &state, NULL, 0);
ts_fail_if (ret == GST_STATE_CHANGE_FAILURE);
if (ret != GST_STATE_CHANGE_SUCCESS || state != GST_STATE_PLAYING)
return TRUE;
if (!ready_to_send)
return TRUE;
if (sending)
{
ts_fail_unless (fs_session_stop_telephony_event (dat->session, method),
"Could not stop telephony event");
sending = FALSE;
ts_fail_unless (received == TRUE, "Did not receive any buffer for digit %d",
digit);
if (digit >= FS_DTMF_EVENT_D && !change_codec)
{
g_main_loop_quit (loop);
return FALSE;
}
}
else
{
if (digit >= FS_DTMF_EVENT_D)
{
digit = 0;
dtmf_id++;
ready_to_send = FALSE;
change_codec = FALSE;
set_codecs (dat, stream);
return TRUE;
}
digit++;
received = FALSE;
ts_fail_unless (fs_session_start_telephony_event (dat->session,
digit, digit, method),
"Could not start telephony event");
sending = TRUE;
}
return TRUE;
}
static void
_handoff_handler (GstElement *element, GstBuffer *buffer, GstPad *pad,
guint stream, gint component_id)
{
ts_fail_unless (gst_buffer_get_size (buffer) == component_id * 10,
"Buffer is size %d but component_id is %d", gst_buffer_get_size (buffer),
component_id);
g_static_mutex_lock (&count_mutex);
buffer_count[stream][component_id-1]++;
if (buffer_count[stream][component_id-1] % 10 == 0)
{
GST_DEBUG ("Buffer %d stream: %u component: %d size: %u",
buffer_count[stream][component_id-1], stream,
component_id, gst_buffer_get_size (buffer));
GST_DEBUG ("Received %d %d %d %d",
buffer_count[0][0], buffer_count[0][1],
buffer_count[1][0], buffer_count[1][1]);
}
ts_fail_if (buffer_count[stream][component_id-1] > 20,
"Too many buffers %d > 20 for component",
buffer_count[stream][component_id-1], component_id);
if (buffer_count[0][0] == 20 && buffer_count[0][1] == 20 &&
buffer_count[1][0] == 20 && buffer_count[1][1] == 20) {
if (associate_on_source)
ts_fail_unless (buffer_count[0][0] == received_known[0][0] &&
buffer_count[0][1] == received_known[0][1] &&
buffer_count[1][0] == received_known[1][0] &&
buffer_count[1][1] == received_known[1][1],
"Some known buffers from known sources have not been reported"
" (%d != %u || %d != %u || %d != %u || %d != %u)",
buffer_count[0][0], received_known[0][0],
buffer_count[0][1], received_known[0][1],
buffer_count[1][0], received_known[1][0],
buffer_count[1][1], received_known[1][1]);
else
ts_fail_unless (received_known[0][0] == 0 &&
received_known[0][1] == 0 &&
received_known[1][0] == 0 &&
received_known[1][1] == 0,
"Got a known-source-packet-received signal when we shouldn't have");
/* TEST OVER */
g_atomic_int_set(&running, FALSE);
g_main_loop_quit (loop);
}
g_static_mutex_unlock (&count_mutex);
}
static void
_src_pad_added (FsStream *stream, GstPad *pad, FsCodec *codec,
gpointer user_data)
{
struct SimpleTestStream *st = user_data;
GstElement *fakesink = gst_element_factory_make ("fakesink", NULL);
GstPad *fakesink_pad = NULL;
GstPadLinkReturn ret;
FsCodec *codeccopy = fs_codec_copy (codec);
gchar *str = NULL;
g_assert (fakesink);
g_object_set (fakesink,
"signal-handoffs", TRUE,
"sync", TRUE,
"async", TRUE,
NULL);
ts_fail_if (codec->encoding_name == NULL,
"Got invalid codec without an encoding_name with id %u"
" and clock_rate %u", codec->id, codec->clock_rate);
g_object_set_data (G_OBJECT (fakesink), "codec", codeccopy);
g_object_weak_ref (G_OBJECT (fakesink),
(GWeakNotify) fs_codec_destroy, codeccopy);
g_signal_connect (fakesink, "handoff", st->handoff_handler, st);
gst_bin_add (GST_BIN (st->dat->pipeline), fakesink);
fakesink_pad = gst_element_get_static_pad (fakesink, "sink");
ret = gst_pad_link (pad, fakesink_pad);
gst_object_unref (fakesink_pad);
ts_fail_if (GST_PAD_LINK_FAILED(ret), "Could not link fakesink");
ts_fail_if (gst_element_set_state (fakesink, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_FAILURE, "Could not set the fakesink to playing");
str = fs_codec_to_string (codec);
GST_DEBUG ("%d:%d: Added Fakesink for codec %s", st->dat->id, st->target->id,
str);
g_free (str);
if (max_src_pads > 1)
ts_fail_unless (count_stream_pads (stream) <= max_src_pads);
else
ts_fail_unless (count_stream_pads (stream) == 1);
}
static void
set_codecs (struct SimpleTestConference *dat, FsStream *stream)
{
GList *codecs = NULL;
GList *filtered_codecs = NULL;
GList *item = NULL;
GError *error = NULL;
FsCodec *dtmf_codec = NULL;
g_object_get (dat->session, "codecs", &codecs, NULL);
ts_fail_if (codecs == NULL, "Could not get the local codecs");
for (item = g_list_first (codecs); item; item = g_list_next (item))
{
FsCodec *codec = item->data;
if (codec->id == 0 || codec->id == 8)
{
filtered_codecs = g_list_append (filtered_codecs, codec);
}
else if (codec->clock_rate == 8000 &&
!g_ascii_strcasecmp (codec->encoding_name, "telephone-event"))
{
ts_fail_unless (dtmf_codec == NULL,
"More than one copy of telephone-event");
dtmf_codec = codec;
filtered_codecs = g_list_append (filtered_codecs, codec);
}
}
ts_fail_if (filtered_codecs == NULL, "PCMA and PCMU are not in the codecs"
" you must install gst-plugins-good");
ts_fail_unless (dtmf_codec != NULL);
dtmf_codec->id = dtmf_id;
if (!fs_stream_set_remote_codecs (stream, filtered_codecs, &error))
{
if (error)
ts_fail ("Could not set the remote codecs on stream (%d): %s",
error->code,
error->message);
else
ts_fail ("Could not set the remote codecs on stream"
" and we did NOT get a GError!!");
}
g_list_free (filtered_codecs);
fs_codec_list_destroy (codecs);
}
static void
_known_source_packet_received (FsStreamTransmitter *st, guint component_id,
GstBuffer *buffer, gpointer user_data)
{
ts_fail_unless (associate_on_source == TRUE,
"Got known-source-packet-received when we shouldn't have");
ts_fail_unless (component_id == 1 || component_id == 2,
"Invalid component id %u", component_id);
ts_fail_unless (GST_IS_BUFFER (buffer), "Invalid buffer received at %p",
buffer);
received_known[component_id - 1]++;
}
static void
_new_local_candidate (FsStream *stream, FsCandidate *candidate)
{
struct SimpleTestStream *st = g_object_get_data (G_OBJECT (stream),
"SimpleTestStream");
gboolean ret;
GError *error = NULL;
struct SimpleTestStream *other_st = find_pointback_stream (st->target,
st->dat);
GList *candidates = NULL;
g_debug ("%d:%d: Setting remote candidate for component %d",
other_st->dat->id,
other_st->target->id,
candidate->component_id);
candidates = g_list_prepend (NULL, candidate);
ret = fs_stream_set_remote_candidates (other_st->stream, candidates, &error);
g_list_free (candidates);
if (error)
ts_fail ("Error while adding candidate: (%s:%d) %s",
g_quark_to_string (error->domain), error->code, error->message);
ts_fail_unless (ret == TRUE, "No detailed error from add_remote_candidate");
}
static void
_handoff_handler (GstElement *element, GstBuffer *buffer, GstPad *pad,
gpointer user_data)
{
gint component_id = GPOINTER_TO_INT (user_data);
ts_fail_unless (GST_BUFFER_SIZE (buffer) == component_id * 10,
"Buffer is size %d but component_id is %d", GST_BUFFER_SIZE (buffer),
component_id);
buffer_count[component_id-1]++;
/*
g_debug ("Buffer %d component: %d size: %u", buffer_count[component_id-1],
component_id, GST_BUFFER_SIZE (buffer));
*/
ts_fail_if (buffer_count[component_id-1] > 20,
"Too many buffers %d > 20 for component",
buffer_count[component_id-1], component_id);
if (buffer_count[0] == 20 && buffer_count[1] == 20) {
/* TEST OVER */
g_main_loop_quit (loop);
}
}
static gboolean
set_the_candidates (gpointer user_data)
{
FsStreamTransmitter *st = FS_STREAM_TRANSMITTER (user_data);
GList *candidates = g_object_get_data (G_OBJECT (st), "candidates-set");
gboolean ret;
GError *error = NULL;
if (!candidates)
{
g_debug ("Skipping libnice check because it found NO local candidates");
g_atomic_int_set(&running, FALSE);
g_main_loop_quit (loop);
return FALSE;
}
if (force_candidates)
{
GList *item = NULL;
GList *next = NULL;
GList *new_list = NULL;
for (item = candidates; item; item = next)
{
FsCandidate *cand = item->data;
GList *item2 = NULL;
next = g_list_next (item);
for (item2 = new_list; item2; item2 = g_list_next (item2))
{
FsCandidate *cand2 = item2->data;
if (cand2->component_id == cand->component_id)
break;
}
if (!item2)
{
candidates = g_list_remove (candidates, cand);
new_list = g_list_append (new_list, cand);
}
}
ret = fs_stream_transmitter_force_remote_candidates (st, new_list, &error);
fs_candidate_list_destroy (new_list);
}
else
{
ret = fs_stream_transmitter_add_remote_candidates (st, candidates, &error);
}
if (error)
ts_fail ("Error while adding candidate: (%s:%d) %s",
g_quark_to_string (error->domain), error->code, error->message);
ts_fail_unless (ret == TRUE, "No detailed error setting remote_candidate");
fs_candidate_list_destroy (candidates);
return FALSE;
}
static void
_new_local_candidate (FsStreamTransmitter *st, FsCandidate *candidate,
gpointer user_data)
{
ts_fail_if (candidate == NULL, "Passed NULL candidate");
ts_fail_unless (candidate->ip != NULL, "Null IP in candidate");
ts_fail_unless (candidate->proto == FS_NETWORK_PROTOCOL_UDP,
"Protocol is not UDP");
ts_fail_unless (candidate->type == FS_CANDIDATE_TYPE_HOST,
"Candidate is not host");
ts_fail_unless (got_candidates[candidate->component_id-1] == FALSE);
got_candidates[candidate->component_id-1] = TRUE;
GST_DEBUG ("New local candidate %s of type %d for component %d",
candidate->ip, candidate->type, candidate->component_id);
}
static void
_new_local_candidate (FsStream *stream, FsCandidate *candidate)
{
struct SimpleTestStream *st = g_object_get_data (G_OBJECT (stream),
"SimpleTestStream");
gboolean ret;
GError *error = NULL;
struct SimpleTestStream *other_st;
GList *candidates = NULL;
TEST_LOCK ();
if (st->target == NULL)
{
TEST_UNLOCK ();
return;
}
other_st = find_pointback_stream (st->target, st->dat);
if (other_st->stream == NULL ||
(candidate->component_id == FS_COMPONENT_RTCP && no_rtcp))
{
TEST_UNLOCK ();
return;
}
st->got_candidates = TRUE;
GST_DEBUG ("%d:%d: Setting remote candidate for component %d",
other_st->dat->id,
other_st->target->id,
candidate->component_id);
if (other_st->stream == NULL)
{
TEST_UNLOCK ();
return;
}
candidates = g_list_prepend (NULL, candidate);
ret = fs_stream_add_remote_candidates (other_st->stream, candidates, &error);
if (ret == FALSE && error &&
error->domain == FS_ERROR && error->code == FS_ERROR_NOT_IMPLEMENTED)
{
g_clear_error (&error);
ret = fs_stream_force_remote_candidates (other_st->stream, candidates,
&error);
}
g_list_free (candidates);
if (error)
ts_fail ("Error while adding candidate: (%s:%d) %s",
g_quark_to_string (error->domain), error->code, error->message);
ts_fail_unless (ret == TRUE, "No detailed error from add_remote_candidate");
TEST_UNLOCK ();
}
static void
_new_active_candidate_pair (FsStreamTransmitter *st, FsCandidate *local,
FsCandidate *remote, gpointer user_data)
{
ts_fail_if (local == NULL, "Local candidate NULL");
ts_fail_if (remote == NULL, "Remote candidate NULL");
ts_fail_unless (local->component_id == remote->component_id,
"Local and remote candidates dont have the same component id");
GST_DEBUG ("New active candidate pair");
}
static void
delete_port_mapping_cb (GUPnPService *service,
GUPnPServiceAction *action,
gpointer user_data)
{
gchar *remote_host = NULL;
guint external_port = 0;
gchar *proto = NULL;
gupnp_service_action_get (action,
"NewRemoteHost", G_TYPE_STRING, &remote_host,
"NewExternalPort", G_TYPE_UINT, &external_port,
"NewProtocol", G_TYPE_STRING, &proto,
NULL);
ts_fail_if (remote_host == NULL, "remote host NULL on remove");
ts_fail_unless (external_port, "external port wrong on remove");
ts_fail_unless (proto && !strcmp (proto, "UDP"), "proto wrong on remove");
gupnp_service_action_return (action);
}
static void
_new_local_candidate (FsStreamTransmitter *st, FsCandidate *candidate,
gpointer user_data)
{
GST_DEBUG ("Has local candidate %s:%u of type %d",
candidate->ip, candidate->port, candidate->type);
ts_fail_if (candidate == NULL, "Passed NULL candidate");
ts_fail_unless (candidate->ip != NULL, "Null IP in candidate");
ts_fail_if (candidate->port == 0, "Candidate has port 0");
ts_fail_unless (candidate->proto == FS_NETWORK_PROTOCOL_UDP,
"Protocol is not UDP");
ts_fail_if (candidate->foundation == NULL,
"Candidate doenst have a foundation");
ts_fail_if (candidate->component_id == 0, "Component id is 0");
if (candidate->type == FS_CANDIDATE_TYPE_HOST)
{
ts_fail_if (candidate->base_ip != NULL, "Host candidate has a base ip");
ts_fail_if (candidate->base_port != 0, "Host candidate has a base port");
}
else
{
ts_fail_if (candidate->base_ip == NULL, "Candidate doesnt have a base ip");
ts_fail_if (candidate->base_port == 0, "Candidate doesnt have a base port");
}
ts_fail_if (candidate->username == NULL, "Candidate doenst have a username");
ts_fail_if (candidate->password == NULL, "Candidate doenst have a password");
GST_DEBUG ("New local candidate %s:%d of type %d for component %d",
candidate->ip, candidate->port, candidate->type, candidate->component_id);
GST_DEBUG ("username: %s password: %s", candidate->username,
candidate->password);
if (is_address_local)
ts_fail_unless (!strcmp (candidate->ip, "127.0.0.1"));
g_object_set_data (G_OBJECT (st), "candidates",
g_list_append (g_object_get_data (G_OBJECT (st), "candidates"),
fs_candidate_copy (candidate)));
}
static void
add_port_mapping_cb (GUPnPService *service,
GUPnPServiceAction *action,
gpointer user_data)
{
gchar *remote_host = NULL;
guint external_port = 0;
gchar *proto = NULL;
guint internal_port = 0;
gchar *internal_client = NULL;
gboolean enabled = -1;
gchar *desc = NULL;
guint lease = 0;
gupnp_service_action_get (action,
"NewRemoteHost", G_TYPE_STRING, &remote_host,
"NewExternalPort", G_TYPE_UINT, &external_port,
"NewProtocol", G_TYPE_STRING, &proto,
"NewInternalPort", G_TYPE_UINT, &internal_port,
"NewInternalClient", G_TYPE_STRING, &internal_client,
"NewEnabled", G_TYPE_BOOLEAN, &enabled,
"NewPortMappingDescription", G_TYPE_STRING, &desc,
"NewLeaseDuration", G_TYPE_UINT, &lease,
NULL);
ts_fail_unless (remote_host && !strcmp (remote_host, ""), "Remote host invalid");
ts_fail_unless (external_port == internal_port, "External and internal ports different");
ts_fail_unless (proto && (!strcmp (proto, "UDP") || !strcmp (proto, "TCP")));
ts_fail_unless (enabled == TRUE, "enable is not true");
ts_fail_unless (desc != NULL, "no desc");
g_free (remote_host);
g_free (proto);
g_free (internal_client);
g_free (desc);
gupnp_service_action_return (action);
added_mapping = TRUE;
}
static void
_double_codec_handoff_handler (GstElement *element, GstBuffer *buffer,
GstPad *pad, gpointer user_data)
{
static int buffer_count [2][2] = {{0,0},{0,0}};
static gpointer sts[2] = {NULL, NULL};
GstPad *peer = gst_pad_get_peer (pad);
gchar *name;
gint session, ssrc, pt;
guint id = 0xFFFFFF;
if (!(sts[0] == user_data || sts[1] == user_data))
{
if (!sts[0])
sts[0] = user_data;
else if (!sts[1])
sts[1] = user_data;
else
ts_fail ("Already have two streams");
}
if (sts[0] == user_data)
id = 0;
else if (sts[1] == user_data)
id = 1;
else
ts_fail ("Should not be here");
ts_fail_if (peer == NULL);
name = gst_pad_get_name (peer);
ts_fail_if (name == NULL);
gst_object_unref (peer);
ts_fail_unless (sscanf (name, "src_%d_%d_%d", &session, &ssrc, &pt) == 3);
g_free (name);
if (pt == 0)
buffer_count[0][id]++;
else if (pt == 8)
buffer_count[1][id]++;
else
ts_fail ("Wrong PT: %d", pt);
if (buffer_count[0][0] > 20 &&
buffer_count[0][1] > 20 &&
buffer_count[1][0] > 20 &&
buffer_count[1][1] > 20 )
{
g_main_loop_quit (loop);
}
}
static void
_handoff_handler (GstElement *element, GstBuffer *buffer, GstPad *pad,
gpointer user_data)
{
gint component_id = GPOINTER_TO_INT (user_data);
ts_fail_unless (gst_buffer_get_size (buffer) == component_id * 10,
"Buffer is size %d but component_id is %d", gst_buffer_get_size (buffer),
component_id);
buffer_count[component_id-1]++;
GST_LOG ("Buffer %d component: %d size: %" G_GSIZE_FORMAT,
buffer_count[component_id-1], component_id, gst_buffer_get_size (buffer));
ts_fail_if (buffer_count[component_id-1] > 20,
"Too many buffers %d > 20 for component",
buffer_count[component_id-1], component_id);
if (buffer_count[0] == 20 && buffer_count[1] == 20) {
GST_DEBUG ("Test complete, got 20 buffers twice");
/* TEST OVER */
if (associate_on_source)
ts_fail_unless (buffer_count[0] == received_known[0] &&
buffer_count[1] == received_known[1], "Some known buffers from known"
" sources have not been reported (%d != %u || %d != %u)",
buffer_count[0], received_known[0],
buffer_count[1], received_known[1]);
else
ts_fail_unless (received_known[0] == 0 && received_known[1] == 0,
"Got a known-source-packet-received signal when we shouldn't have");
g_mutex_lock (&test_mutex);
done = TRUE;
g_mutex_unlock (&test_mutex);
g_cond_signal (&cond);
}
}
static void
handoff_handler (GstElement *fakesink, GstBuffer *buffer, GstPad *pad,
gpointer user_data)
{
g_mutex_lock (&count_mutex);
buffer_count ++;
GST_LOG ("buffer %d", buffer_count);
if (buffer_count == BUFFER_COUNT)
g_cond_broadcast (&count_cond);
ts_fail_unless (buffer_count <= SEND_BUFFER_COUNT);
g_mutex_unlock (&count_mutex);
}
static void
change_ssrc_handler (GstPad *pad, GstBuffer *buf, gpointer user_data)
{
guint sess_ssrc;
guint buf_ssrc;
ts_fail_unless (gst_rtp_buffer_validate (buf));
buf_ssrc = gst_rtp_buffer_get_ssrc (buf);
g_object_get (dat->session, "ssrc", &sess_ssrc, NULL);
if (buf_ssrc == 12345)
{
/* Step two, set it to 6789 */
ts_fail_unless (buf_ssrc == sess_ssrc || sess_ssrc == 6789);
g_object_set (dat->session, "ssrc", 6789, NULL);
}
else if (buf_ssrc == 6789)
{
/* Step three, quit */
ts_fail_unless (buf_ssrc == sess_ssrc);
g_main_loop_quit (loop);
}
else
{
ts_fail_unless (checked || buf_ssrc == sess_ssrc);
checked = TRUE;
/* Step one, set the ssrc to 12345 */
if (sess_ssrc != 12345)
g_object_set (dat->session, "ssrc", 12345, NULL);
}
}
static GstElement *
build_recv_pipeline (GCallback havedata_handler, gpointer data, gint *port)
{
GstElement *pipeline;
GstElement *src;
GstElement *sink;
GstPad *pad = NULL;
pipeline = gst_pipeline_new (NULL);
src = gst_element_factory_make ("udpsrc", NULL);
sink = gst_element_factory_make ("fakesink", NULL);
g_object_set (sink, "sync", FALSE, NULL);
ts_fail_unless (pipeline && src && sink, "Could not make pipeline(%p)"
" or src(%p) or sink(%p)", pipeline, src, sink);
gst_bin_add_many (GST_BIN (pipeline), src, sink, NULL);
ts_fail_unless (gst_element_link (src, sink), "Could not link udpsrc"
" and fakesink");
pad = gst_element_get_static_pad (sink, "sink");
gst_pad_add_buffer_probe (pad, havedata_handler, data);
gst_object_ref (pad);
ts_fail_if (gst_element_set_state (pipeline, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_FAILURE, "Could not start recv pipeline");
g_object_get (G_OBJECT (src), "port", port, NULL);
return pipeline;
}
static void
element_added (FsElementAddedNotifier *notif, GstBin *bin, GstElement *element,
gpointer user_data)
{
GstElementFactory *fact = gst_element_get_factory (element);
if (!fact)
return;
if (strcmp (gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (fact)),
"theoradec"))
return;
ts_fail_unless (decoder_count == 0);
decoder_count++;
}
static void
_new_active_candidate_pair (FsStreamTransmitter *st, FsCandidate *local,
FsCandidate *remote, gpointer user_data)
{
ts_fail_if (local == NULL, "Local candidate NULL");
ts_fail_if (remote == NULL, "Remote candidate NULL");
ts_fail_unless (local->component_id == remote->component_id,
"Local and remote candidates dont have the same component id");
g_debug ("New active candidate pair for component %d", local->component_id);
if (!src_setup[local->component_id-1])
setup_fakesrc (user_data, pipeline, local->component_id);
src_setup[local->component_id-1] = TRUE;
}
static void
_simple_profile_init (struct SimpleTestStream *st, guint confid, guint streamid)
{
GList *prefs = NULL;
FsCodec *codec = NULL;
gboolean ret;
codec = fs_codec_new (0, "PCMU", FS_MEDIA_TYPE_AUDIO, 8000);
fs_codec_add_optional_parameter (codec, "farstream-send-profile",
"audioconvert ! audioresample ! audioconvert ! mulawenc ! rtppcmupay");
prefs = g_list_append (NULL, codec);
ret = fs_session_set_codec_preferences (st->dat->session, prefs,
NULL);
ts_fail_unless (ret, "set codec prefs");
fs_codec_list_destroy (prefs);
}
static void
send_dmtf_havedata_handler (GstPad *pad, GstBuffer *buf, gpointer user_data)
{
gchar *data;
ts_fail_unless (gst_rtp_buffer_validate (buf), "Buffer is not valid rtp");
if (gst_rtp_buffer_get_payload_type (buf) != dtmf_id)
return;
data = gst_rtp_buffer_get_payload (buf);
if (data[0] < digit)
{
/* Still on previou digit */
return;
}
ts_fail_if (data[0] != digit, "Not sending the right digit"
" (sending %d, should be %d", data[0], digit);
received = TRUE;
}
static void
multicast_init (struct SimpleTestStream *st, guint confid, guint streamid)
{
GList *candidates = NULL;
FsCandidate *cand;
GError *error = NULL;
cand = fs_candidate_new ("1", FS_COMPONENT_RTP,
FS_CANDIDATE_TYPE_MULTICAST, FS_NETWORK_PROTOCOL_UDP, "224.0.0.11",
2324);
cand->ttl = 1;
candidates = g_list_prepend (candidates, cand);
cand = fs_candidate_copy (cand);
cand->component_id = FS_COMPONENT_RTCP;
cand->port = 2325;
candidates = g_list_prepend (candidates, cand);
ts_fail_unless (fs_stream_force_remote_candidates (st->stream, candidates,
&error), "Error %s", error ? error->message : "No GError");
fs_candidate_list_destroy (candidates);
}
static gboolean
_bus_callback (GstBus *bus, GstMessage *message, gpointer user_data)
{
struct SimpleTestConference *dat = user_data;
switch (GST_MESSAGE_TYPE (message))
{
case GST_MESSAGE_ELEMENT:
{
const GstStructure *s = gst_message_get_structure (message);
if (gst_implements_interface_check (GST_MESSAGE_SRC (message),
FS_TYPE_CONFERENCE) &&
gst_structure_has_name (s, "farsight-error"))
{
const GValue *value;
FsError errorno;
const gchar *error, *debug;
GEnumClass *enumclass = NULL;
GEnumValue *enumvalue = NULL;
ts_fail_unless (
gst_implements_interface_check (GST_MESSAGE_SRC (message),
FS_TYPE_CONFERENCE),
"Received farsight-error from non-farsight element");
ts_fail_unless (
gst_structure_has_field_typed (s, "src-object", G_TYPE_OBJECT),
"farsight-error structure has no src-object field");
ts_fail_unless (
gst_structure_has_field_typed (s, "error-no", FS_TYPE_ERROR),
"farsight-error structure has no src-object field");
ts_fail_unless (
gst_structure_has_field_typed (s, "error-msg", G_TYPE_STRING),
"farsight-error structure has no src-object field");
ts_fail_unless (
gst_structure_has_field_typed (s, "debug-msg", G_TYPE_STRING),
"farsight-error structure has no src-object field");
value = gst_structure_get_value (s, "error-no");
errorno = g_value_get_enum (value);
error = gst_structure_get_string (s, "error-msg");
debug = gst_structure_get_string (s, "debug-msg");
enumclass = g_type_class_ref (FS_TYPE_ERROR);
enumvalue = g_enum_get_value (enumclass, errorno);
ts_fail ("Error on BUS %s (%d, %s) %s .. %s",
enumvalue->value_name, errorno, enumvalue->value_nick,
error, debug);
g_type_class_unref (enumclass);
}
else if (gst_structure_has_name (s, "farsight-send-codec-changed"))
{
ready_to_send = TRUE;
}
}
break;
case GST_MESSAGE_ERROR:
{
GError *error = NULL;
gchar *debug = NULL;
gst_message_parse_error (message, &error, &debug);
ts_fail ("Got an error on the BUS (%d): %s (%s)", error->code,
error->message, debug);
g_error_free (error);
g_free (debug);
}
break;
case GST_MESSAGE_WARNING:
{
GError *error = NULL;
gchar *debug = NULL;
gst_message_parse_warning (message, &error, &debug);
GST_WARNING ("%d: Got a warning on the BUS (%d): %s (%s)", dat->id,
error->code,
error->message, debug);
g_error_free (error);
g_free (debug);
}
break;
default:
break;
}
return TRUE;
}
static void
one_way (GCallback havedata_handler, gpointer data)
{
FsParticipant *participant = NULL;
GError *error = NULL;
gint port = 0;
GstElement *recv_pipeline;
GList *candidates = NULL;
GstBus *bus = NULL;
dtmf_id = 105;
digit = 0;
sending = FALSE;
received = FALSE;
ready_to_send = FALSE;
loop = g_main_loop_new (NULL, FALSE);
dat = setup_simple_conference (1, "fsrtpconference", "tester@123445");
bus = gst_element_get_bus (dat->pipeline);
gst_bus_add_watch (bus, _bus_callback, dat);
gst_object_unref (bus);
g_idle_add (_start_pipeline, dat);
participant = fs_conference_new_participant (
FS_CONFERENCE (dat->conference), "*****@*****.**", &error);
if (error)
ts_fail ("Error while creating new participant (%d): %s",
error->code, error->message);
ts_fail_if (dat->session == NULL,
"Could not make participant, but no GError!");
stream = fs_session_new_stream (dat->session, participant,
FS_DIRECTION_SEND, "rawudp", 0, NULL, &error);
if (error)
ts_fail ("Error while creating new stream (%d): %s",
error->code, error->message);
ts_fail_if (stream == NULL, "Could not make stream, but no GError!");
recv_pipeline = build_recv_pipeline (havedata_handler, NULL, &port);
GST_DEBUG ("port is %d", port);
candidates = g_list_prepend (NULL,
fs_candidate_new ("1", FS_COMPONENT_RTP, FS_CANDIDATE_TYPE_HOST,
FS_NETWORK_PROTOCOL_UDP, "127.0.0.1", port));
ts_fail_unless (fs_stream_set_remote_candidates (stream, candidates, &error),
"Could not set remote candidate");
fs_candidate_list_destroy (candidates);
set_codecs (dat, stream);
setup_fakesrc (dat);
g_main_loop_run (loop);
gst_element_set_state (dat->pipeline, GST_STATE_NULL);
gst_element_set_state (recv_pipeline, GST_STATE_NULL);
cleanup_simple_conference (dat);
gst_object_unref (recv_pipeline);
g_main_loop_unref (loop);
}
