From: Nicolas Dufresne Date: Tue, 27 Nov 2018 22:10:57 +0000 (-0500) Subject: test: rtpssrcdemux: Test event forwarding X-Git-Tag: 1.16.2~290 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c596bdda38305f3e58a315d30c82d2549bef59aa;p=platform%2Fupstream%2Fgst-plugins-good.git test: rtpssrcdemux: Test event forwarding This the first unit test of this element. It adds a test that verify that events are forwarded correctly. --- diff --git a/tests/check/Makefile.am b/tests/check/Makefile.am index 5d9e74b..87b3ca2 100644 --- a/tests/check/Makefile.am +++ b/tests/check/Makefile.am @@ -256,6 +256,7 @@ check_rtpmanager = \ elements/rtpred \ elements/rtpulpfec \ elements/rtpfunnel + elements/rtpssrcdemux \ else check_rtpmanager = endif diff --git a/tests/check/elements/rtpssrcdemux.c b/tests/check/elements/rtpssrcdemux.c new file mode 100644 index 0000000..a8b093b --- /dev/null +++ b/tests/check/elements/rtpssrcdemux.c @@ -0,0 +1,189 @@ +/* GStreamer + * + * Copyright (C) 2018 Collabora Ltd. + * Author: Nicolas Dufresne + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ +#include +#include +#include + +#define TEST_BUF_CLOCK_RATE 8000 +#define TEST_BUF_PT 0 +#define TEST_BUF_SSRC 0x01BADBAD +#define TEST_BUF_MS 20 +#define TEST_BUF_DURATION (TEST_BUF_MS * GST_MSECOND) +#define TEST_BUF_SIZE (64000 * TEST_BUF_MS / 1000) +#define TEST_RTP_TS_DURATION (TEST_BUF_CLOCK_RATE * TEST_BUF_MS / 1000) + +static GstCaps * +generate_caps (void) +{ + return gst_caps_new_simple ("application/x-rtp", + "media", G_TYPE_STRING, "audio", + "clock-rate", G_TYPE_INT, TEST_BUF_CLOCK_RATE, NULL); +} + +static GstBuffer * +create_buffer (guint seq_num, guint32 ssrc) +{ + GstBuffer *buf; + guint8 *payload; + guint i; + GstClockTime dts = seq_num * TEST_BUF_DURATION; + guint32 rtp_ts = seq_num * TEST_RTP_TS_DURATION; + GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; + + buf = gst_rtp_buffer_new_allocate (TEST_BUF_SIZE, 0, 0); + GST_BUFFER_DTS (buf) = dts; + + gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtp); + gst_rtp_buffer_set_payload_type (&rtp, TEST_BUF_PT); + gst_rtp_buffer_set_seq (&rtp, seq_num); + gst_rtp_buffer_set_timestamp (&rtp, rtp_ts); + gst_rtp_buffer_set_ssrc (&rtp, ssrc); + + payload = gst_rtp_buffer_get_payload (&rtp); + for (i = 0; i < TEST_BUF_SIZE; i++) + payload[i] = 0xff; + + gst_rtp_buffer_unmap (&rtp); + + return buf; +} + +typedef struct +{ + GstHarness *rtp_sink; + GstHarness *rtcp_sink; + GstHarness *rtp_src; + GstHarness *rtcp_src; +} TestContext; + +static void +rtpssrcdemux_pad_added (G_GNUC_UNUSED GstElement * demux, GstPad * src_pad, + TestContext * ctx) +{ + GstHarness *h; + + h = gst_harness_new_with_element (ctx->rtp_sink->element, NULL, + GST_PAD_NAME (src_pad)); + + /* FIXME We should also check that pads have current caps, but this is not + * currently the case as both pads are created when the first pad receive a + * buffer. If the other pad is not linked, you'll get a pad without caps. + * Changing this implies not having both pads on 'on-new-ssrc' which would + * break rtpbin assumption. */ + + if (g_str_has_prefix (GST_PAD_NAME (src_pad), "src_")) { + g_assert (ctx->rtp_src == NULL); + ctx->rtp_src = h; + } else if (g_str_has_prefix (GST_PAD_NAME (src_pad), "rtcp_src_")) { + g_assert (ctx->rtcp_src == NULL); + ctx->rtcp_src = h; + } else { + g_assert_not_reached (); + } +} + +GST_START_TEST (test_event_forwarding) +{ + TestContext ctx = { NULL, }; + GstHarness *h; + GstEvent *event; + GstCaps *caps; + GstStructure *s; + guint ssrc; + + ctx.rtp_sink = h = gst_harness_new_with_padnames ("rtpssrcdemux", "sink", + NULL); + g_signal_connect (h->element, "pad_added", + G_CALLBACK (rtpssrcdemux_pad_added), &ctx); + + ctx.rtcp_sink = gst_harness_new_with_element (h->element, "rtcp_sink", NULL); + + gst_harness_set_src_caps (h, generate_caps ()); + gst_harness_push (h, create_buffer (0, TEST_BUF_SSRC)); + + g_assert (ctx.rtp_src); + g_assert (ctx.rtcp_src); + + gst_harness_push_event (h, gst_event_new_eos ()); + + /* We expect stream-start/caps/segment/eos */ + g_assert_cmpint (gst_harness_events_in_queue (ctx.rtp_src), ==, 4); + + event = gst_harness_pull_event (ctx.rtp_src); + g_assert_cmpint (event->type, ==, GST_EVENT_STREAM_START); + gst_event_unref (event); + + event = gst_harness_pull_event (ctx.rtp_src); + g_assert_cmpint (event->type, ==, GST_EVENT_CAPS); + gst_event_parse_caps (event, &caps); + s = gst_caps_get_structure (caps, 0); + g_assert (gst_structure_has_field (s, "ssrc")); + g_assert (gst_structure_get_uint (s, "ssrc", &ssrc)); + g_assert_cmpuint (ssrc, ==, TEST_BUF_SSRC); + gst_event_unref (event); + + event = gst_harness_pull_event (ctx.rtp_src); + g_assert_cmpint (event->type, ==, GST_EVENT_SEGMENT); + gst_event_unref (event); + + event = gst_harness_pull_event (ctx.rtp_src); + g_assert_cmpint (event->type, ==, GST_EVENT_EOS); + gst_event_unref (event); + + /* We pushed on the RTP pad, no events should have reached the RTCP pad */ + g_assert_cmpint (gst_harness_events_in_queue (ctx.rtcp_src), ==, 0); + + /* push EOS on the rtcp sink pad, to make sure it EOS properly, the harness + * will create the missing stream-start */ + gst_harness_push_event (ctx.rtcp_sink, gst_event_new_eos ()); + + g_assert_cmpint (gst_harness_events_in_queue (ctx.rtp_src), ==, 0); + g_assert_cmpint (gst_harness_events_in_queue (ctx.rtcp_src), ==, 2); + + event = gst_harness_pull_event (ctx.rtcp_src); + g_assert_cmpint (event->type, ==, GST_EVENT_STREAM_START); + gst_event_unref (event); + + event = gst_harness_pull_event (ctx.rtcp_src); + g_assert_cmpint (event->type, ==, GST_EVENT_EOS); + gst_event_unref (event); + + gst_harness_teardown (ctx.rtp_src); + gst_harness_teardown (ctx.rtcp_src); + gst_harness_teardown (ctx.rtcp_sink); + gst_harness_teardown (ctx.rtp_sink); +} + +GST_END_TEST; + +static Suite * +rtpssrcdemux_suite (void) +{ + Suite *s = suite_create ("rtpssrcdemux"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + tcase_add_test (tc_chain, test_event_forwarding); + + return s; +} + +GST_CHECK_MAIN (rtpssrcdemux); diff --git a/tests/check/meson.build b/tests/check/meson.build index 4b7f3f9..7ba0cb2 100644 --- a/tests/check/meson.build +++ b/tests/check/meson.build @@ -83,6 +83,7 @@ good_tests = [ [ 'elements/rtpstorage' ], [ 'elements/rtpred' ], [ 'elements/rtpulpfec' ], + [ 'elements/rtpssrcdemux' ], [ 'elements/souphttpsrc', not libsoup_dep.found(), [libsoup_dep] ], [ 'elements/spectrum' ], [ 'elements/shapewipe' ],