From 71bdb5e088850479a56790d2b671c88e0cc2b7c9 Mon Sep 17 00:00:00 2001 From: Julien Isorce Date: Fri, 1 Nov 2013 16:22:13 +0000 Subject: [PATCH] tests/check: add rtprtx::test_drop_multiple_sender unit test Several senders / one receiver Similar than test_drop_one_sender but with multiple senders mixed through the funnel element. It drops some packets and checks that they are retransmited correctly. --- tests/check/elements/rtprtx.c | 496 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 496 insertions(+) diff --git a/tests/check/elements/rtprtx.c b/tests/check/elements/rtprtx.c index 4c51394..b1b8f1d 100644 --- a/tests/check/elements/rtprtx.c +++ b/tests/check/elements/rtprtx.c @@ -563,6 +563,501 @@ GST_START_TEST (test_drop_one_sender) GST_END_TEST; +GMutex lock_eos; +static gint nb_sources; +static gint nb_eos; + +static void +message_received_multiple (GstBus * bus, GstMessage * message, + GstPipeline * bin) +{ + GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT, + GST_MESSAGE_SRC (message), message); + + switch (message->type) { + case GST_MESSAGE_EOS: + g_main_loop_quit (main_loop); + break; + case GST_MESSAGE_WARNING:{ + GError *gerror; + gchar *debug; + + gst_message_parse_warning (message, &gerror, &debug); + gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug); + g_error_free (gerror); + g_free (debug); + break; + } + case GST_MESSAGE_ERROR:{ + GError *gerror; + gchar *debug; + + gst_message_parse_error (message, &gerror, &debug); + gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug); + g_error_free (gerror); + g_free (debug); + g_main_loop_quit (main_loop); + break; + } + default: + break; + } +} + +typedef struct +{ + guint count; + guint nb_packets; + guint drop_every_n_packets; + guint payload_type_master; +} RTXSendMultipleData; + +/* drop some packets */ +static GstPadProbeReturn +rtprtxsend_srcpad_probe_multiple (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + GstPadProbeReturn ret = GST_PAD_PROBE_OK; + + if (info->type == (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH)) { + GstBuffer *buffer = GST_BUFFER (info->data); + RTXSendMultipleData *rtxdata = (RTXSendMultipleData *) user_data; + GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; + guint payload_type = 0; + + gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp); + payload_type = gst_rtp_buffer_get_payload_type (&rtp); + + /* main stream packets */ + if (payload_type == rtxdata->payload_type_master) { + /* count packets of the main stream */ + ++rtxdata->nb_packets; + /* drop some packets */ + if (rtxdata->count < rtxdata->drop_every_n_packets) { + ++rtxdata->count; + } else { + /* drop a packet every 'rtxdata->count' packets */ + rtxdata->count = 1; + ret = GST_PAD_PROBE_DROP; + } + } else { + /* retransmission packets */ + } + + gst_rtp_buffer_unmap (&rtp); + } + + return ret; +} + +/* make sure every sources has sent all their buffers */ +static GstPadProbeReturn +source_srcpad_probe_multiple (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + GstPadProbeReturn ret = GST_PAD_PROBE_OK; + + if (info->type == + (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | GST_PAD_PROBE_TYPE_PUSH)) { + GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info); + if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) { + g_mutex_lock (&lock_eos); + ++nb_eos; + if (nb_eos < nb_sources) + ret = GST_PAD_PROBE_DROP; + g_mutex_unlock (&lock_eos); + } + } + + return ret; +} + +/* add one branch videotestsrc ! rtpvrawpay ! rtprtxsend ! queue ! funnel. */ +static RTXSendMultipleData * +add_sender (GstElement * bin, const gchar * src_name, + const gchar * payloader_name, guint payload_type_master, + guint payload_type_aux) +{ + GstElement *src = NULL; + GstElement *rtppayloader = NULL; + GstElement *rtprtxsend = NULL; + GstElement *queue = NULL; + GstElement *funnel = NULL; + GstPad *srcpad = NULL; + gboolean res = FALSE; + RTXSendMultipleData *send_rtxdata = g_slice_new0 (RTXSendMultipleData); + + send_rtxdata->count = 1; + send_rtxdata->nb_packets = 0; + send_rtxdata->drop_every_n_packets = 0; + send_rtxdata->payload_type_master = payload_type_master; + + src = gst_element_factory_make (src_name, NULL); + rtppayloader = gst_element_factory_make (payloader_name, NULL); + rtprtxsend = gst_element_factory_make ("rtprtxsend", NULL); + queue = gst_element_factory_make ("queue", NULL); + funnel = gst_bin_get_by_name (GST_BIN (bin), "funnel"); + + g_object_set (src, "num-buffers", 25, NULL); + g_object_set (rtppayloader, "pt", payload_type_master, NULL); + g_object_set (rtppayloader, "seqnum-offset", 1, NULL); + g_object_set (rtprtxsend, "rtx-payload-type", payload_type_aux, NULL); + /* we want that every drop packet be resent fast */ + g_object_set (queue, "max-size-buffers", 1, NULL); + g_object_set (queue, "flush-on-eos", FALSE, NULL); + + gst_bin_add_many (GST_BIN (bin), src, rtppayloader, rtprtxsend, queue, NULL); + + res = gst_element_link (src, rtppayloader); + fail_unless (res == TRUE, NULL); + res = gst_element_link (rtppayloader, rtprtxsend); + fail_unless (res == TRUE, NULL); + res = gst_element_link (rtprtxsend, queue); + fail_unless (res == TRUE, NULL); + res = gst_element_link (queue, funnel); + fail_unless (res == TRUE, NULL); + gst_object_unref (funnel); + + /* to drop some packets */ + srcpad = gst_element_get_static_pad (rtprtxsend, "src"); + gst_pad_add_probe (srcpad, + (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH), + (GstPadProbeCallback) rtprtxsend_srcpad_probe_multiple, send_rtxdata, + NULL); + gst_object_unref (srcpad); + + /* to make sure every sources has sent all their buffers */ + srcpad = gst_element_get_static_pad (queue, "src"); + gst_pad_add_probe (srcpad, + (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | GST_PAD_PROBE_TYPE_PUSH), + (GstPadProbeCallback) source_srcpad_probe_multiple, NULL, NULL); + gst_object_unref (srcpad); + + ++nb_sources; + + return send_rtxdata; +} + +typedef struct +{ + GHashTable *ssrc_to_nb_packets_map; + GHashTable *ssrc_to_seqnum_offset_map; + guint seqnum_offset; +} RTXReceiveMultipleData; + +static GstPadProbeReturn +rtprtxreceive_srcpad_probe_multiple (GstPad * pad, GstPadProbeInfo * info, + gpointer user_data) +{ + if (info->type == (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH)) { + GstBuffer *buffer = GST_BUFFER (info->data); + RTXReceiveMultipleData *rtxdata = (RTXReceiveMultipleData *) user_data; + GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; + guint ssrc = 0; + guint seqnum = 0; + gpointer seqnum_prev = 0; + guint nb_packets = 0; + + gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp); + ssrc = gst_rtp_buffer_get_ssrc (&rtp); + seqnum = gst_rtp_buffer_get_seq (&rtp); + + if (!g_hash_table_lookup_extended (rtxdata->ssrc_to_seqnum_offset_map, + GUINT_TO_POINTER (ssrc), NULL, &seqnum_prev)) { + /*In our test we take care to never drop the first buffer */ + g_hash_table_insert (rtxdata->ssrc_to_seqnum_offset_map, + GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (seqnum)); + g_hash_table_insert (rtxdata->ssrc_to_nb_packets_map, + GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (1)); + return GST_PAD_PROBE_OK; + } + + /* check if there is a dropped packet + * (in our test every packet arrived in increasing order) */ + if (seqnum > GPOINTER_TO_UINT (seqnum_prev) + rtxdata->seqnum_offset) { + GstPad *peerpad = gst_pad_get_peer (pad); + guint i = 0; + + /* ask retransmission of missing packets */ + for (i = GPOINTER_TO_UINT (seqnum_prev) + rtxdata->seqnum_offset; + i < seqnum; i += rtxdata->seqnum_offset) { + GstEvent *event = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM, + gst_structure_new ("GstRTPRetransmissionRequest", + "seqnum", G_TYPE_UINT, i, + "ssrc", G_TYPE_UINT, gst_rtp_buffer_get_ssrc (&rtp), + "payload-type", G_TYPE_UINT, + gst_rtp_buffer_get_payload_type (&rtp), + NULL)); + gst_pad_push_event (peerpad, event); + } + gst_object_unref (peerpad); + + g_hash_table_insert (rtxdata->ssrc_to_seqnum_offset_map, + GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (seqnum)); + } else if (seqnum == + GPOINTER_TO_UINT (seqnum_prev) + rtxdata->seqnum_offset) { + /* also update previous seqnum in this case */ + g_hash_table_insert (rtxdata->ssrc_to_seqnum_offset_map, + GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (seqnum)); + } else { + /* receive retransmited packet */ + } + + gst_rtp_buffer_unmap (&rtp); + + nb_packets = + GPOINTER_TO_UINT (g_hash_table_lookup (rtxdata->ssrc_to_nb_packets_map, + GUINT_TO_POINTER (ssrc))); + g_hash_table_insert (rtxdata->ssrc_to_nb_packets_map, + GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (++nb_packets)); + } + + return GST_PAD_PROBE_OK; +} + +static void +reset_rtx_send_data (RTXSendMultipleData * send_rtxdata, gpointer data) +{ + send_rtxdata->count = 1; + send_rtxdata->nb_packets = 0; + send_rtxdata->drop_every_n_packets = *(guint *) data; +} + +/* compute number of all packets sent by all sender */ +static void +compute_total_packets_sent (RTXSendMultipleData * send_rtxdata, gpointer data) +{ + guint *sum = (guint *) data; + *sum += send_rtxdata->nb_packets; +} + +/* compute number of all packets received by rtprtxreceive::src pad */ +static void +compute_total_packets_received (gpointer key, gpointer value, gpointer data) +{ + guint *sum = (guint *) data; + *sum += GPOINTER_TO_UINT (value); +} + +static void +start_test_drop_multiple_and_check_results (GstElement * bin, + GList * send_rtxdata_list, RTXReceiveMultipleData * receive_rtxdata, + guint drop_every_n_packets) +{ + GstStateChangeReturn state_res = GST_STATE_CHANGE_FAILURE; + GstElement *rtprtxreceive = + gst_bin_get_by_name (GST_BIN (bin), "rtprtxreceive"); + guint sum_all_packets_sent = 0; + guint sum_rtx_packets_sent = 0; + guint sum_all_packets_received = 0; + guint sum_rtx_packets_received = 0; + guint sum_rtx_assoc_packets_received = 0; + guint sum_rtx_dropped_packets_received = 0; + gdouble error_sent_recv = 0; + GstIterator *itr_elements = NULL; + gboolean done = FALSE; + GValue item = { 0 }; + GstElement *element = NULL; + gchar *name = NULL; + + GST_INFO ("starting test"); + + g_hash_table_remove_all (receive_rtxdata->ssrc_to_nb_packets_map); + g_hash_table_remove_all (receive_rtxdata->ssrc_to_seqnum_offset_map); + + g_list_foreach (send_rtxdata_list, (GFunc) reset_rtx_send_data, + &drop_every_n_packets); + + /* run pipeline */ + state_res = gst_element_set_state (bin, GST_STATE_PLAYING); + ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE); + + state_res = gst_element_get_state (bin, NULL, NULL, GST_CLOCK_TIME_NONE); + ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE); + + GST_INFO ("running main loop"); + g_main_loop_run (main_loop); + + /* check results */ + itr_elements = gst_bin_iterate_elements (GST_BIN (bin)); + done = FALSE; + while (!done) { + switch (gst_iterator_next (itr_elements, &item)) { + case GST_ITERATOR_OK: + element = GST_ELEMENT (g_value_get_object (&item)); + name = gst_element_get_name (element); + if (g_str_has_prefix (name, "rtprtxsend") > 0) { + guint nb_packets = 0; + g_object_get (G_OBJECT (element), "num-rtx-packets", &nb_packets, + NULL); + sum_rtx_packets_sent += nb_packets; + } + g_free (name); + g_value_reset (&item); + break; + case GST_ITERATOR_RESYNC: + gst_iterator_resync (itr_elements); + break; + case GST_ITERATOR_ERROR: + done = TRUE; + break; + case GST_ITERATOR_DONE: + done = TRUE; + break; + } + } + g_value_unset (&item); + gst_iterator_free (itr_elements); + + /* compute number of all packets sent by all sender */ + g_list_foreach (send_rtxdata_list, (GFunc) compute_total_packets_sent, + &sum_all_packets_sent); + + /* compute number of all packets received by rtprtxreceive::src pad */ + g_hash_table_foreach (receive_rtxdata->ssrc_to_nb_packets_map, + compute_total_packets_received, (gpointer) & sum_all_packets_received); + + /* check that we sent as many packets as received */ + /* when eos is received by sources we cannot ensure that every packets + * will be received by sinks (maybe queue flush ?) + */ + fail_if (sum_all_packets_sent < sum_all_packets_received); + + /* some packet are not received, I still have to figure out why + * but I suspect it comes from pipeline setup/shutdown + */ + if (sum_all_packets_sent != sum_all_packets_received) { + error_sent_recv = + 1 - sum_all_packets_received / (gdouble) sum_all_packets_sent; + fail_if (error_sent_recv > 0.30); + /* it should be 0% */ + } + + /* retrieve number of retransmit packets received by rtprtxreceive */ + g_object_get (G_OBJECT (rtprtxreceive), "num-rtx-packets", + &sum_rtx_packets_received, NULL); + + /* some of rtx packet are not received because the receiver avoids + * collision (= requests that have the same seqnum) + */ + fail_if (sum_rtx_packets_sent < sum_rtx_packets_received); + g_object_get (G_OBJECT (rtprtxreceive), "num-rtx-assoc-packets", + &sum_rtx_assoc_packets_received, NULL); + sum_rtx_dropped_packets_received = + sum_rtx_packets_received - sum_rtx_assoc_packets_received; + fail_unless_equals_int (sum_rtx_packets_sent, + sum_rtx_assoc_packets_received + sum_rtx_dropped_packets_received); + + gst_object_unref (rtprtxreceive); + state_res = gst_element_set_state (bin, GST_STATE_NULL); + ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE); +} + +static void +free_rtx_send_data (gpointer data) +{ + g_slice_free (RTXSendMultipleData, data); +} + +/* This test build the pipeline funnel name=funnel + * videotestsrc ! rtpvrawpay ! rtprtxsend ! queue ! funnel. + * videotestsrc ! rtpvrawpay ! rtprtxsend ! queue ! funnel. + * N + * funnel. ! rtprtxreceive ! fakesink + * and drop some buffer just after each rtprtxsend + * Then it checks that every dropped packet has been re-sent and it checks + * that not too much requests has been sent. + */ +GST_START_TEST (test_drop_multiple_sender) +{ + GstElement *bin, *funnel, *rtprtxreceive, *sink; + GstBus *bus; + gboolean res; + GstPad *srcpad; + guint drop_every_n_packets = 0; + GList *send_rtxdata_list = NULL; + RTXReceiveMultipleData receive_rtxdata; + + GST_INFO ("preparing test"); + + receive_rtxdata.ssrc_to_nb_packets_map = + g_hash_table_new (g_direct_hash, g_direct_equal); + receive_rtxdata.ssrc_to_seqnum_offset_map = + g_hash_table_new (g_direct_hash, g_direct_equal); + receive_rtxdata.seqnum_offset = 1; + + /* build pipeline */ + bin = gst_pipeline_new ("pipeline"); + bus = gst_element_get_bus (bin); + gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH); + + funnel = gst_element_factory_make ("funnel", "funnel"); + rtprtxreceive = gst_element_factory_make ("rtprtxreceive", "rtprtxreceive"); + sink = gst_element_factory_make ("fakesink", "sink"); + g_object_set (sink, "sync", TRUE, NULL); + g_object_set (sink, "qos", FALSE, NULL); + gst_bin_add_many (GST_BIN (bin), funnel, rtprtxreceive, sink, NULL); + + nb_sources = 0; + g_mutex_init (&lock_eos); + + send_rtxdata_list = + g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc", + "rtpvrawpay", 96, 121)); + send_rtxdata_list = + g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc", + "rtpvrawpay", 97, 122)); + send_rtxdata_list = + g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc", + "rtpvrawpay", 98, 123)); + send_rtxdata_list = + g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc", + "rtpvrawpay", 99, 124)); + + res = gst_element_link (funnel, rtprtxreceive); + fail_unless (res == TRUE, NULL); + res = gst_element_link (rtprtxreceive, sink); + fail_unless (res == TRUE, NULL); + + srcpad = gst_element_get_static_pad (rtprtxreceive, "src"); + gst_pad_add_probe (srcpad, + (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH), + (GstPadProbeCallback) rtprtxreceive_srcpad_probe_multiple, + &receive_rtxdata, NULL); + gst_object_unref (srcpad); + + main_loop = g_main_loop_new (NULL, FALSE); + g_signal_connect (bus, "message::error", + (GCallback) message_received_multiple, bin); + g_signal_connect (bus, "message::warning", + (GCallback) message_received_multiple, bin); + g_signal_connect (bus, "message::eos", (GCallback) message_received_multiple, + bin); + + for (drop_every_n_packets = 2; drop_every_n_packets < 10; + drop_every_n_packets++) { + g_object_set (rtprtxreceive, "rtx-payload-types", "121:122:123:124", NULL); + nb_eos = 0; + start_test_drop_multiple_and_check_results (bin, send_rtxdata_list, + &receive_rtxdata, drop_every_n_packets); + } + + /* cleanup */ + g_main_loop_unref (main_loop); + + g_list_free_full (send_rtxdata_list, free_rtx_send_data); + g_hash_table_destroy (receive_rtxdata.ssrc_to_nb_packets_map); + g_hash_table_destroy (receive_rtxdata.ssrc_to_seqnum_offset_map); + + gst_bus_remove_signal_watch (bus); + gst_object_unref (bus); + gst_object_unref (bin); + + g_mutex_clear (&lock_eos); +} + +GST_END_TEST; + static Suite * rtprtx_suite (void) { @@ -575,6 +1070,7 @@ rtprtx_suite (void) tcase_add_test (tc_chain, test_push_forward_seq); tcase_add_test (tc_chain, test_drop_one_sender); + tcase_add_test (tc_chain, test_drop_multiple_sender); return s; } -- 2.7.4