mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 13:48:55 +00:00
550 lines
17 KiB
C
550 lines
17 KiB
C
/* GStreamer plugin for forward error correction
|
|
* Copyright (C) 2017 Pexip
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Author: Mikhail Fludkov <misha@pexip.com>
|
|
*/
|
|
|
|
#include <gst/rtp/gstrtpbuffer.h>
|
|
#include <gst/check/gstcheck.h>
|
|
#include <gst/check/gstharness.h>
|
|
|
|
#include "../../../gst/rtp/gstrtpstorage.h"
|
|
#include "../../../gst/rtp/rtpstorage.h"
|
|
|
|
#define RTP_CLOCK_RATE (90000)
|
|
#define RTP_FRAME_DUR (RTP_CLOCK_RATE / 30)
|
|
|
|
#define RTP_TSTAMP_BASE (0x11111111)
|
|
#define GST_TSTAMP_BASE (0x22222222)
|
|
#define RTP_TSTAMP(i) (RTP_FRAME_DUR * (i) + RTP_TSTAMP_BASE)
|
|
#define GST_TSTAMP(i) (RTP_PACKET_DUR * (i) + GST_TSTAMP_BASE)
|
|
|
|
#define RTP_PACKET_DUR (10 * GST_MSECOND)
|
|
|
|
static GstBufferList *
|
|
get_packets_for_recovery (GstHarness * h, gint fec_pt, guint32 ssrc,
|
|
guint16 lost_seq)
|
|
{
|
|
GstBufferList *res;
|
|
RtpStorage *internal_storage;
|
|
|
|
g_object_get (h->element, "internal-storage", &internal_storage, NULL);
|
|
|
|
res =
|
|
rtp_storage_get_packets_for_recovery (internal_storage, fec_pt, ssrc,
|
|
lost_seq);
|
|
|
|
g_object_unref (internal_storage);
|
|
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
put_recovered_packet (GstHarness * h, GstBuffer * buffer, guint8 pt,
|
|
guint32 ssrc, guint16 seq)
|
|
{
|
|
RtpStorage *internal_storage;
|
|
|
|
g_object_get (h->element, "internal-storage", &internal_storage, NULL);
|
|
|
|
rtp_storage_put_recovered_packet (internal_storage, buffer, pt, ssrc, seq);
|
|
|
|
g_object_unref (internal_storage);
|
|
}
|
|
|
|
static GstBuffer *
|
|
create_rtp_packet (guint8 pt, guint32 ssrc, guint32 timestamp, guint16 seq)
|
|
{
|
|
GstBuffer *buf = gst_rtp_buffer_new_allocate (0, 0, 0);
|
|
GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
|
|
|
|
fail_unless (gst_rtp_buffer_map (buf, GST_MAP_WRITE, &rtp));
|
|
gst_rtp_buffer_set_ssrc (&rtp, ssrc);
|
|
gst_rtp_buffer_set_payload_type (&rtp, pt);
|
|
gst_rtp_buffer_set_timestamp (&rtp, timestamp);
|
|
gst_rtp_buffer_set_seq (&rtp, seq);
|
|
GST_BUFFER_DTS (buf) = GST_TSTAMP (seq);
|
|
gst_rtp_buffer_unmap (&rtp);
|
|
|
|
return buf;
|
|
}
|
|
|
|
GST_START_TEST (rtpstorage_up_and_down)
|
|
{
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
gst_harness_set_src_caps_str (h, "application/x-rtp");
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_resize)
|
|
{
|
|
guint i, j;
|
|
GstBuffer *bufin, *bufout, *bufs[10];
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
|
|
gst_harness_set_src_caps_str (h, "application/x-rtp");
|
|
|
|
g_object_set (h->element, "size-time", (guint64) 0, NULL);
|
|
bufin = create_rtp_packet (96, 0xabe2b0b, 0x111111, 0);
|
|
bufout = gst_harness_push_and_pull (h, bufin);
|
|
fail_unless (bufin == bufout);
|
|
fail_unless (gst_buffer_is_writable (bufout));
|
|
|
|
g_object_set (h->element,
|
|
"size-time", (guint64) (G_N_ELEMENTS (bufs) - 1) * RTP_PACKET_DUR, NULL);
|
|
|
|
// Pushing 10 buffers all of them should have ref. count =2
|
|
for (i = 0; i < G_N_ELEMENTS (bufs); ++i) {
|
|
bufs[i] =
|
|
gst_harness_push_and_pull (h, create_rtp_packet (96, 0xabe2b0b,
|
|
0x111111, i));
|
|
for (j = 0; j <= i; ++j)
|
|
fail_unless (!gst_buffer_is_writable (bufs[j]));
|
|
}
|
|
|
|
// The next 10 buffers should expel the first 10
|
|
for (i = 0; i < G_N_ELEMENTS (bufs); ++i) {
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, 0x111111, G_N_ELEMENTS (bufs) + i)));
|
|
for (j = 0; j <= i; ++j)
|
|
fail_unless (gst_buffer_is_writable (bufs[j]));
|
|
}
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (bufs); ++i)
|
|
gst_buffer_unref (bufs[i]);
|
|
gst_buffer_unref (bufout);
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_stop_redundant_packets)
|
|
{
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
GstBuffer *bufinp;
|
|
|
|
g_object_set (h->element, "size-time", (guint64) 2 * RTP_PACKET_DUR, NULL);
|
|
gst_harness_set_src_caps_str (h, "application/x-rtp");
|
|
|
|
bufinp = create_rtp_packet (96, 0xabe2b0b, 0x111111, 0);
|
|
GST_BUFFER_FLAG_SET (bufinp, GST_RTP_BUFFER_FLAG_REDUNDANT);
|
|
gst_harness_push (h, bufinp);
|
|
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, 0x111111, 1)));
|
|
|
|
fail_unless_equals_int (gst_harness_buffers_received (h), 1);
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_unknown_ssrc)
|
|
{
|
|
GstBufferList *bufs_out;
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
g_object_set (h->element, "size-time", (guint64) RTP_PACKET_DUR, NULL);
|
|
gst_harness_set_src_caps_str (h, "application/x-rtp");
|
|
|
|
/* No packets has been pushed through yet */
|
|
bufs_out = get_packets_for_recovery (h, 100, 0xabe2b0b, 0);
|
|
fail_unless (NULL == bufs_out);
|
|
|
|
/* 1 packet with ssrc=0xabe2bob pushed. Asking for ssrc=0xdeadbeef */
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, 0x111111, 0)));
|
|
bufs_out = get_packets_for_recovery (h, 100, 0xdeadbeef, 0);
|
|
fail_unless (NULL == bufs_out);
|
|
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_packet_not_lost)
|
|
{
|
|
GstBuffer *buf;
|
|
GstBufferList *bufs_out;
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
g_object_set (h->element, "size-time", (guint64) 10 * RTP_PACKET_DUR, NULL);
|
|
gst_harness_set_src_caps_str (h, "application/x-rtp");
|
|
|
|
/* Pushing through 2 frames + 2 FEC */
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, RTP_TSTAMP (0), 0)));
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, (buf =
|
|
create_rtp_packet (96, 0xabe2b0b, RTP_TSTAMP (1), 1))));
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, RTP_TSTAMP (1), 2)));
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, RTP_TSTAMP (1), 3)));
|
|
|
|
/* Asking for a packet which was pushed before */
|
|
bufs_out = get_packets_for_recovery (h, 100, 0xabe2b0b, 1);
|
|
fail_unless (NULL != bufs_out);
|
|
fail_unless_equals_int (1, gst_buffer_list_length (bufs_out));
|
|
fail_unless (gst_buffer_list_get (bufs_out, 0) == buf);
|
|
|
|
gst_buffer_list_unref (bufs_out);
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_rtpstorage_put_recovered_packet)
|
|
{
|
|
GstBuffer *bufs_in[4];
|
|
GstBufferList *bufs_out;
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
g_object_set (h->element, "size-time", (guint64) 10 * RTP_PACKET_DUR, NULL);
|
|
gst_harness_set_src_caps_str (h, "application/x-rtp");
|
|
|
|
/* Pushing through 2 frames + 2 FEC
|
|
* Packets with sequence numbers 1 and 2 are lost */
|
|
bufs_in[0] = create_rtp_packet (96, 0xabe2b0b, RTP_TSTAMP (0), 0);
|
|
bufs_in[1] = NULL;
|
|
bufs_in[2] = NULL;
|
|
bufs_in[3] = create_rtp_packet (100, 0xabe2b0b, RTP_TSTAMP (1), 3);
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, bufs_in[0]));
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, bufs_in[3]));
|
|
|
|
/* 1 more frame + 1 FEC */
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, RTP_TSTAMP (2), 4)));
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (100,
|
|
0xabe2b0b, RTP_TSTAMP (2), 5)));
|
|
|
|
/* Asking for the lost packet seq=1 */
|
|
bufs_out = get_packets_for_recovery (h, 100, 0xabe2b0b, 1);
|
|
fail_unless (NULL != bufs_out);
|
|
fail_unless_equals_int (2, gst_buffer_list_length (bufs_out));
|
|
fail_unless (gst_buffer_list_get (bufs_out, 0) == bufs_in[0]);
|
|
fail_unless (gst_buffer_list_get (bufs_out, 1) == bufs_in[3]);
|
|
gst_buffer_list_unref (bufs_out);
|
|
|
|
/* During recovery the packet of a new frame has arrived */
|
|
gst_buffer_unref (gst_harness_push_and_pull (h, create_rtp_packet (96,
|
|
0xabe2b0b, RTP_TSTAMP (3), 6)));
|
|
|
|
/* Say we recovered packet with seq=1 and put it back in the storage */
|
|
bufs_in[1] = create_rtp_packet (96, 0xabe2b0b, RTP_TSTAMP (1), 1);
|
|
put_recovered_packet (h, bufs_in[1], 96, 0xabe2b0b, 1);
|
|
|
|
/* Asking for the lost packet seq=2 */
|
|
bufs_out = get_packets_for_recovery (h, 100, 0xabe2b0b, 2);
|
|
fail_unless (NULL != bufs_out);
|
|
fail_unless_equals_int (3, gst_buffer_list_length (bufs_out));
|
|
fail_unless (gst_buffer_list_get (bufs_out, 0) == bufs_in[0]);
|
|
fail_unless (gst_buffer_list_get (bufs_out, 1) == bufs_in[1]);
|
|
fail_unless (gst_buffer_list_get (bufs_out, 2) == bufs_in[3]);
|
|
gst_buffer_list_unref (bufs_out);
|
|
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
static void
|
|
_single_ssrc_test (GstHarness * h, guint32 ssrc,
|
|
guint16 seq_start, guint16 nth_to_loose,
|
|
gsize expected_buf_size, gsize expected_first_buffer_idx)
|
|
{
|
|
guint i;
|
|
GPtrArray *bufs_in =
|
|
g_ptr_array_new_with_free_func ((GDestroyNotify) gst_buffer_unref);
|
|
GstBufferList *bufs_out;
|
|
|
|
/* 2 frames + 2 FEC */
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (96, ssrc, RTP_TSTAMP (0),
|
|
seq_start + 0));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (96, ssrc, RTP_TSTAMP (1),
|
|
seq_start + 1));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (100, ssrc, RTP_TSTAMP (1),
|
|
seq_start + 2));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (100, ssrc, RTP_TSTAMP (1),
|
|
seq_start + 3));
|
|
/* 3 frames + 2 FEC */
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (96, ssrc, RTP_TSTAMP (2),
|
|
seq_start + 4));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (96, ssrc, RTP_TSTAMP (3),
|
|
seq_start + 5));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (96, ssrc, RTP_TSTAMP (4),
|
|
seq_start + 6));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (100, ssrc, RTP_TSTAMP (4),
|
|
seq_start + 7));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (100, ssrc, RTP_TSTAMP (4),
|
|
seq_start + 8));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (100, ssrc, RTP_TSTAMP (4),
|
|
seq_start + 9));
|
|
/* 2 frames + no FEC */
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (96, ssrc, RTP_TSTAMP (5),
|
|
seq_start + 10));
|
|
g_ptr_array_add (bufs_in, create_rtp_packet (96, ssrc, RTP_TSTAMP (6),
|
|
seq_start + 11));
|
|
|
|
/* Losing one */
|
|
g_ptr_array_remove_index (bufs_in, nth_to_loose);
|
|
|
|
/* Push all of them through */
|
|
for (i = 0; i < bufs_in->len; ++i)
|
|
gst_buffer_unref (gst_harness_push_and_pull (h,
|
|
gst_buffer_ref (g_ptr_array_index (bufs_in, i))));
|
|
|
|
bufs_out =
|
|
get_packets_for_recovery (h, 100, ssrc,
|
|
(guint16) (seq_start + nth_to_loose));
|
|
if (0 == expected_buf_size) {
|
|
fail_unless (NULL == bufs_out);
|
|
} else {
|
|
fail_unless (NULL != bufs_out);
|
|
fail_unless_equals_int (expected_buf_size,
|
|
gst_buffer_list_length (bufs_out));
|
|
for (i = 0; i < gst_buffer_list_length (bufs_out); ++i)
|
|
fail_unless (gst_buffer_list_get (bufs_out, i) ==
|
|
g_ptr_array_index (bufs_in, expected_first_buffer_idx + i));
|
|
gst_buffer_list_unref (bufs_out);
|
|
}
|
|
g_ptr_array_unref (bufs_in);
|
|
}
|
|
|
|
static void
|
|
_multiple_ssrcs_test (guint16 nth_to_loose,
|
|
gsize expected_buf_size, gsize expected_first_buffer_idx)
|
|
{
|
|
guint16 stream0_seq_start = 200;
|
|
guint16 stream1_seq_start = 65529;
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
g_object_set (h->element, "size-time", (guint64) 12 * RTP_PACKET_DUR, NULL);
|
|
gst_harness_set_src_caps_str (h, "application/x-rtp");
|
|
|
|
_single_ssrc_test (h, 0x0abe2b0b, stream0_seq_start,
|
|
nth_to_loose, expected_buf_size, expected_first_buffer_idx);
|
|
_single_ssrc_test (h, 0xdeadbeef, stream1_seq_start,
|
|
nth_to_loose, expected_buf_size, expected_first_buffer_idx);
|
|
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern0)
|
|
{
|
|
_multiple_ssrcs_test (1, 3, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern1)
|
|
{
|
|
_multiple_ssrcs_test (2, 3, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern2)
|
|
{
|
|
_multiple_ssrcs_test (3, 6, 3);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern3)
|
|
{
|
|
_multiple_ssrcs_test (4, 5, 4);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern4)
|
|
{
|
|
_multiple_ssrcs_test (5, 5, 4);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern5)
|
|
{
|
|
_multiple_ssrcs_test (6, 5, 4);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern6)
|
|
{
|
|
_multiple_ssrcs_test (7, 5, 4);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern7)
|
|
{
|
|
_multiple_ssrcs_test (8, 5, 4);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern8)
|
|
{
|
|
_multiple_ssrcs_test (9, 0, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (rtpstorage_loss_pattern9)
|
|
{
|
|
_multiple_ssrcs_test (10, 0, 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
#define STRESS_TEST_SSRCS (8)
|
|
#define STRESS_TEST_STORAGE_DEPTH (50)
|
|
typedef struct _StressTestData StressTestData;
|
|
struct _StressTestData
|
|
{
|
|
guint16 seq[STRESS_TEST_SSRCS];
|
|
guint32 ssrc[STRESS_TEST_SSRCS];
|
|
gsize count[STRESS_TEST_SSRCS];
|
|
GRand *rnd;
|
|
};
|
|
|
|
static GstBuffer *
|
|
rtpstorage_stress_prepare_buffer (GstHarness * h, gpointer data)
|
|
{
|
|
static const guint8 fec_pt = 100;
|
|
static const guint8 media_pt = 96;
|
|
StressTestData *test_data = data;
|
|
gsize ssrc_idx = g_rand_int_range (test_data->rnd, 0, STRESS_TEST_SSRCS);
|
|
guint16 seq = test_data->seq[ssrc_idx];
|
|
guint32 ssrc = test_data->ssrc[ssrc_idx];
|
|
gboolean is_fec = test_data->count[ssrc_idx] > 0 && (seq % 5 == 0
|
|
|| seq % 5 == 1);
|
|
guint8 pt = is_fec ? fec_pt : media_pt;
|
|
|
|
GstBuffer *buf = create_rtp_packet (pt, ssrc, RTP_TSTAMP (0), seq);
|
|
|
|
++test_data->seq[ssrc_idx];
|
|
++test_data->count[ssrc_idx];
|
|
return buf;
|
|
}
|
|
|
|
GST_START_TEST (rtpstorage_stress)
|
|
{
|
|
GRand *rnd;
|
|
GTimer *timer;
|
|
GstCaps *caps;
|
|
GstSegment segment;
|
|
GstHarnessThread *ht;
|
|
StressTestData test_data;
|
|
guint seed, i, total, requested;
|
|
GstHarness *h = gst_harness_new ("rtpstorage");
|
|
g_object_set (h->element,
|
|
"size-time", (guint64) STRESS_TEST_STORAGE_DEPTH * RTP_PACKET_DUR, NULL);
|
|
|
|
/* The stress test pushes buffers with STRESS_TEST_SSRCS different
|
|
* ssrcs from one thread and requests packets for FEC recovery from
|
|
* another thread.
|
|
* */
|
|
memset (&test_data, 0, sizeof (test_data));
|
|
seed = g_random_int ();
|
|
test_data.rnd = g_rand_new_with_seed (seed);
|
|
for (i = 0; i < STRESS_TEST_SSRCS; ++i) {
|
|
test_data.ssrc[i] = 0x00112233 + i * 0x01000000;
|
|
test_data.seq[i] = g_rand_int_range (test_data.rnd, 0, 0x10000);
|
|
}
|
|
|
|
gst_segment_init (&segment, GST_FORMAT_TIME);
|
|
caps = gst_caps_from_string ("application/x-rtp");
|
|
rnd = g_rand_copy (test_data.rnd);
|
|
|
|
GST_INFO ("%u seed", seed);
|
|
ht = gst_harness_stress_push_buffer_with_cb_start (h, caps, &segment,
|
|
rtpstorage_stress_prepare_buffer, &test_data, NULL);
|
|
|
|
requested = 0;
|
|
timer = g_timer_new ();
|
|
while (g_timer_elapsed (timer, NULL) < 2) {
|
|
gsize ssrc_idx = g_rand_int_range (rnd, 0, STRESS_TEST_SSRCS);
|
|
|
|
/* The following if statement is simply keeping the log
|
|
* clean from ERROR messages */
|
|
if (*((volatile gsize *) &test_data.count[ssrc_idx]) > 1) {
|
|
guint16 lost_seq = *((volatile guint16 *) &test_data.seq[ssrc_idx]) - 5;
|
|
|
|
GstBufferList *bufs_out = get_packets_for_recovery (h, 100,
|
|
test_data.ssrc[ssrc_idx], lost_seq);
|
|
if (bufs_out) {
|
|
requested += gst_buffer_list_length (bufs_out);
|
|
gst_buffer_list_unref (bufs_out);
|
|
}
|
|
}
|
|
|
|
/* Having sleep here makes it hard to detect the race, but we need it to
|
|
* allow another thread to push more buffers when running under valgrind */
|
|
g_usleep (G_USEC_PER_SEC / 10000);
|
|
}
|
|
|
|
gst_harness_stress_thread_stop (ht);
|
|
for (i = 0, total = 0; i < STRESS_TEST_SSRCS; ++i) {
|
|
GST_INFO ("SSRC 0x%08x: %u packets", test_data.ssrc[i],
|
|
(guint32) test_data.count[i]);
|
|
total += test_data.count[i];
|
|
}
|
|
GST_INFO ("%u packets pushed through, %u requested", total, requested);
|
|
|
|
g_rand_free (rnd);
|
|
g_rand_free (test_data.rnd);
|
|
gst_caps_unref (caps);
|
|
g_timer_destroy (timer);
|
|
gst_harness_teardown (h);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static Suite *
|
|
rtpstorage_suite (void)
|
|
{
|
|
Suite *s = suite_create ("rtpstorage");
|
|
TCase *tc_chain = tcase_create ("general");
|
|
|
|
gst_element_register (NULL, "rtpstorage", GST_RANK_NONE,
|
|
GST_TYPE_RTP_STORAGE);
|
|
|
|
suite_add_tcase (s, tc_chain);
|
|
tcase_add_test (tc_chain, rtpstorage_up_and_down);
|
|
tcase_add_test (tc_chain, rtpstorage_resize);
|
|
tcase_add_test (tc_chain, rtpstorage_stop_redundant_packets);
|
|
tcase_add_test (tc_chain, rtpstorage_unknown_ssrc);
|
|
tcase_add_test (tc_chain, rtpstorage_packet_not_lost);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern0);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern1);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern2);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern3);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern4);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern5);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern6);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern7);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern8);
|
|
tcase_add_test (tc_chain, rtpstorage_loss_pattern9);
|
|
tcase_add_test (tc_chain, test_rtpstorage_put_recovered_packet);
|
|
tcase_add_test (tc_chain, rtpstorage_stress);
|
|
|
|
return s;
|
|
}
|
|
|
|
GST_CHECK_MAIN (rtpstorage)
|