static void
fail_unless_perfect_stream (void)
{
guint64 timestamp = 0L, duration = 0L;
guint64 offset = 0L, offset_end = 0L;
GList *l;
GstBuffer *buffer;
for (l = buffers; l; l = l->next) {
buffer = GST_BUFFER (l->data);
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
GST_DEBUG ("buffer timestamp %" G_GUINT64_FORMAT ", duration %"
G_GUINT64_FORMAT, GST_BUFFER_TIMESTAMP (buffer),
GST_BUFFER_DURATION (buffer));
fail_unless_equals_uint64 (timestamp, GST_BUFFER_TIMESTAMP (buffer));
fail_unless_equals_uint64 (offset, GST_BUFFER_OFFSET (buffer));
duration = GST_BUFFER_DURATION (buffer);
offset_end = GST_BUFFER_OFFSET_END (buffer);
timestamp += duration;
offset = offset_end;
gst_buffer_unref (buffer);
}
g_list_free (buffers);
buffers = NULL;
}
static void
test_srt_do_test (SubParseInputChunk * input, guint start_idx, guint num)
{
guint n;
GstCaps *outcaps;
GST_LOG ("srt test: start_idx = %u, num = %u", start_idx, num);
setup_subparse ();
for (n = start_idx; n < start_idx + num; ++n) {
GstBuffer *buf;
buf = buffer_from_static_string (input[n].in);
fail_unless_equals_int (gst_pad_push (mysrcpad, buf), GST_FLOW_OK);
}
gst_pad_push_event (mysrcpad, gst_event_new_eos ());
fail_unless_equals_int (g_list_length (buffers), num);
outcaps = gst_pad_get_current_caps (mysinkpad);
for (n = start_idx; n < start_idx + num; ++n) {
const GstStructure *buffer_caps_struct;
GstBuffer *buf;
GstMapInfo map;
buf = g_list_nth_data (buffers, n - start_idx);
fail_unless (buf != NULL);
fail_unless (GST_BUFFER_TIMESTAMP_IS_VALID (buf), NULL);
fail_unless (GST_BUFFER_DURATION_IS_VALID (buf), NULL);
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (buf), input[n].from_ts);
fail_unless_equals_uint64 (GST_BUFFER_DURATION (buf),
input[n].to_ts - input[n].from_ts);
gst_buffer_map (buf, &map, GST_MAP_READ);
/* can be NULL */
if (map.data != NULL) {
/* shouldn't have trailing newline characters */
fail_if (map.size > 0 && map.data[map.size - 1] == '\n');
/* shouldn't include NUL-terminator in data size */
fail_if (map.size > 0 && map.data[map.size - 1] == '\0');
/* but should still have a NUL-terminator behind the declared data */
fail_unless_equals_int (map.data[map.size], '\0');
/* make sure out string matches expected string */
fail_unless_equals_string ((gchar *) map.data, input[n].out);
}
gst_buffer_unmap (buf, &map);
/* check caps */
fail_unless (outcaps != NULL);
buffer_caps_struct = gst_caps_get_structure (outcaps, 0);
fail_unless (gst_structure_has_name (buffer_caps_struct, "text/x-raw"));
fail_unless_equals_string (gst_structure_get_string (buffer_caps_struct,
"format"), "pango-markup");
}
gst_caps_unref (outcaps);
teardown_subparse ();
}
static void
do_test (SubParseInputChunk * input, guint num, const gchar * media_type)
{
guint n;
setup_subparse ();
for (n = 0; n < num; ++n) {
GstBuffer *buf;
buf = buffer_from_static_string (input[n].in);
fail_unless_equals_int (gst_pad_push (mysrcpad, buf), GST_FLOW_OK);
}
gst_pad_push_event (mysrcpad, gst_event_new_eos ());
fail_unless_equals_int (g_list_length (buffers), num);
for (n = 0; n < num; ++n) {
const GstStructure *buffer_caps_struct;
GstBuffer *buf;
gchar *out;
guint out_size;
buf = g_list_nth_data (buffers, n);
fail_unless (buf != NULL);
/* check timestamp */
fail_unless (GST_BUFFER_TIMESTAMP_IS_VALID (buf), NULL);
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (buf), input[n].from_ts);
/* might not be able to put a duration on the last buffer */
if (input[n].to_ts != GST_CLOCK_TIME_NONE) {
/* check duration */
fail_unless (GST_BUFFER_DURATION_IS_VALID (buf), NULL);
fail_unless_equals_uint64 (GST_BUFFER_DURATION (buf),
input[n].to_ts - input[n].from_ts);
}
out = (gchar *) GST_BUFFER_DATA (buf);
out_size = GST_BUFFER_SIZE (buf);
/* shouldn't have trailing newline characters */
fail_if (out_size > 0 && out[out_size - 1] == '\n');
/* shouldn't include NUL-terminator in data size */
fail_if (out_size > 0 && out[out_size - 1] == '\0');
/* but should still have a NUL-terminator behind the declared data */
fail_unless_equals_int (out[out_size], '\0');
/* make sure out string matches expected string */
fail_unless_equals_string (out, input[n].out);
/* check caps */
fail_unless (GST_BUFFER_CAPS (buf) != NULL);
buffer_caps_struct = gst_caps_get_structure (GST_BUFFER_CAPS (buf), 0);
fail_unless_equals_string (gst_structure_get_name (buffer_caps_struct),
media_type);
}
teardown_subparse ();
}
static void
test_srt_do_test (SubParseInputChunk * input, guint start_idx, guint num)
{
guint n;
GST_LOG ("srt test: start_idx = %u, num = %u", start_idx, num);
setup_subparse ();
for (n = start_idx; n < start_idx + num; ++n) {
GstBuffer *buf;
buf = buffer_from_static_string (input[n].in);
fail_unless_equals_int (gst_pad_push (mysrcpad, buf), GST_FLOW_OK);
}
gst_pad_push_event (mysrcpad, gst_event_new_eos ());
fail_unless_equals_int (g_list_length (buffers), num);
for (n = start_idx; n < start_idx + num; ++n) {
const GstStructure *buffer_caps_struct;
GstBuffer *buf;
gchar *out;
guint out_size;
buf = g_list_nth_data (buffers, n - start_idx);
fail_unless (buf != NULL);
fail_unless (GST_BUFFER_TIMESTAMP_IS_VALID (buf), NULL);
fail_unless (GST_BUFFER_DURATION_IS_VALID (buf), NULL);
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (buf), input[n].from_ts);
fail_unless_equals_uint64 (GST_BUFFER_DURATION (buf),
input[n].to_ts - input[n].from_ts);
out = (gchar *) GST_BUFFER_DATA (buf);
out_size = GST_BUFFER_SIZE (buf);
/* shouldn't have trailing newline characters */
fail_if (out_size > 0 && out[out_size - 1] == '\n');
/* shouldn't include NUL-terminator in data size */
fail_if (out_size > 0 && out[out_size - 1] == '\0');
/* but should still have a NUL-terminator behind the declared data */
fail_unless_equals_int (out[out_size], '\0');
/* make sure out string matches expected string */
fail_unless_equals_string (out, input[n].out);
/* check caps */
fail_unless (GST_BUFFER_CAPS (buf) != NULL);
buffer_caps_struct = gst_caps_get_structure (GST_BUFFER_CAPS (buf), 0);
fail_unless_equals_string (gst_structure_get_name (buffer_caps_struct),
"text/x-pango-markup");
}
teardown_subparse ();
}
static void
check_clip_times (GstBuffer * buffer, GstClockTime start, GstClockTime prev)
{
guint64 keyindex, keyoffset, granulepos;
granulepos = GST_BUFFER_OFFSET_END (buffer);
if (granuleshift == 0 || granuleshift == 64)
keyindex = 0;
else
keyindex = granulepos >> granuleshift;
keyoffset = granulepos - (keyindex << granuleshift);
fail_unless_equals_uint64 (keyindex * granulerate, prev);
fail_unless_equals_uint64 ((keyindex + keyoffset) * granulerate, start);
}
/* this tests that the output is a correct discontinuous stream
* if the input is; ie input drops in time come out the same way */
static void
test_discont_stream_instance (int inrate, int outrate, int samples,
int numbuffers)
{
GstElement *audioresample;
GstBuffer *inbuffer, *outbuffer;
GstCaps *caps;
GstClockTime ints;
int i, j;
gint16 *p;
audioresample = setup_audioresample (2, inrate, outrate);
caps = gst_pad_get_negotiated_caps (mysrcpad);
fail_unless (gst_caps_is_fixed (caps));
fail_unless (gst_element_set_state (audioresample,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
for (j = 1; j <= numbuffers; ++j) {
inbuffer = gst_buffer_new_and_alloc (samples * 4);
GST_BUFFER_DURATION (inbuffer) = samples * GST_SECOND / inrate;
/* "drop" half the buffers */
ints = GST_BUFFER_DURATION (inbuffer) * 2 * (j - 1);
GST_BUFFER_TIMESTAMP (inbuffer) = ints;
GST_BUFFER_OFFSET (inbuffer) = (j - 1) * 2 * samples;
GST_BUFFER_OFFSET_END (inbuffer) = j * 2 * samples + samples;
gst_buffer_set_caps (inbuffer, caps);
p = (gint16 *) GST_BUFFER_DATA (inbuffer);
/* create a 16 bit signed ramp */
for (i = 0; i < samples; ++i) {
*p = -32767 + i * (65535 / samples);
++p;
*p = -32767 + i * (65535 / samples);
++p;
}
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
/* check if the timestamp of the pushed buffer matches the incoming one */
outbuffer = g_list_nth_data (buffers, g_list_length (buffers) - 1);
fail_if (outbuffer == NULL);
fail_unless_equals_uint64 (ints, GST_BUFFER_TIMESTAMP (outbuffer));
if (j > 1) {
fail_unless (GST_BUFFER_IS_DISCONT (outbuffer),
"expected discont buffer");
}
}
/* cleanup */
gst_caps_unref (caps);
cleanup_audioresample (audioresample);
}
static GstPadProbeReturn
qtdemux_probe (GstPad * pad, GstPadProbeInfo * info, CommonTestData * data)
{
GstBuffer *buf = GST_PAD_PROBE_INFO_BUFFER (info);
fail_unless_equals_int (gst_buffer_get_size (buf), data->expected_size);
fail_unless_equals_uint64 (GST_BUFFER_PTS (buf), data->expected_time);
gst_buffer_unref (buf);
return GST_PAD_PROBE_HANDLED;
}
/* return TRUE to discard the Segment */
static gboolean
compare_segments (CollectStructure * collect, Segment * segment,
GstEvent * event)
{
const GstSegment *received_segment;
guint64 running_stop, running_start, running_duration;
gst_event_parse_segment (event, &received_segment);
GST_DEBUG ("Got Segment rate:%f, format:%s, start:%" GST_TIME_FORMAT
", stop:%" GST_TIME_FORMAT ", time:%" GST_TIME_FORMAT
", base:%" GST_TIME_FORMAT ", offset:%" GST_TIME_FORMAT,
received_segment->rate, gst_format_get_name (received_segment->format),
GST_TIME_ARGS (received_segment->start),
GST_TIME_ARGS (received_segment->stop),
GST_TIME_ARGS (received_segment->time),
GST_TIME_ARGS (received_segment->base),
GST_TIME_ARGS (received_segment->offset));
GST_DEBUG ("[RUNNING] start:%" GST_TIME_FORMAT " [STREAM] start:%"
GST_TIME_FORMAT,
GST_TIME_ARGS (gst_segment_to_running_time (received_segment,
GST_FORMAT_TIME, received_segment->start)),
GST_TIME_ARGS (gst_segment_to_stream_time (received_segment,
GST_FORMAT_TIME, received_segment->start)));
GST_DEBUG ("Expecting rate:%f, format:%s, start:%" GST_TIME_FORMAT
", stop:%" GST_TIME_FORMAT ", position:%" GST_TIME_FORMAT ", base:%"
GST_TIME_FORMAT, segment->rate, gst_format_get_name (segment->format),
GST_TIME_ARGS (segment->start), GST_TIME_ARGS (segment->stop),
GST_TIME_ARGS (segment->position),
GST_TIME_ARGS (collect->expected_base));
running_start =
gst_segment_to_running_time (received_segment, GST_FORMAT_TIME,
received_segment->start);
running_stop =
gst_segment_to_running_time (received_segment, GST_FORMAT_TIME,
received_segment->stop);
running_duration = running_stop - running_start;
fail_if (received_segment->rate != segment->rate);
fail_if (received_segment->format != segment->format);
fail_unless_equals_int64 (received_segment->time, segment->position);
fail_unless_equals_int64 (received_segment->base, collect->expected_base);
fail_unless_equals_uint64 (received_segment->stop - received_segment->start,
segment->stop - segment->start);
collect->expected_base += running_duration;
GST_DEBUG ("Segment was valid, discarding expected Segment");
return TRUE;
}
static void
do_ntp_time (GstClockTime buffer_time, gint segment_start, gint segment_base)
{
GstSegment segment;
GstBuffer *buffer;
GstRTPBuffer rtpbuffer = GST_RTP_BUFFER_INIT;
guint8 *data;
guint64 expected_ntp_time;
guint64 timestamp;
/* create a segment that controls the behavior
* by changing segment.start and segment.base we affect the stream time and
* running time respectively */
gst_segment_init (&segment, GST_FORMAT_TIME);
segment.start = segment_start;
segment.base = segment_base;
gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment));
expected_ntp_time = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME,
buffer_time);
expected_ntp_time += NTP_OFFSET;
expected_ntp_time = gst_util_uint64_scale (expected_ntp_time,
(G_GINT64_CONSTANT (1) << 32), GST_SECOND);
buffer = create_rtp_buffer (buffer_time, FALSE);
fail_unless_equals_int (gst_pad_push (mysrcpad, buffer), GST_FLOW_OK);
fail_unless_equals_int (g_list_length (buffers), 1);
buffer = g_list_last (buffers)->data;
/* get the extension header */
fail_unless (gst_rtp_buffer_map (buffer, GST_MAP_READWRITE, &rtpbuffer));
fail_unless (gst_rtp_buffer_get_extension_data (&rtpbuffer, NULL,
(gpointer) & data, NULL));
/* ...and read the NTP timestamp and verify that it's the expected one */
timestamp = GST_READ_UINT64_BE (data);
fail_unless_equals_uint64 (timestamp, expected_ntp_time);
gst_rtp_buffer_unmap (&rtpbuffer);
gst_check_drop_buffers ();
}
static void
check_buffer_equal (GstBuffer * buf, GstBuffer * expected)
{
GstMapInfo info_buf, info_expected;
fail_if (buf == NULL);
fail_if (expected == NULL);
fail_unless (gst_buffer_map (buf, &info_buf, GST_MAP_READ));
fail_unless (gst_buffer_map (expected, &info_expected, GST_MAP_READ));
GST_LOG ("buffer: size %" G_GSIZE_FORMAT, info_buf.size);
GST_LOG ("expected: size %" G_GSIZE_FORMAT, info_expected.size);
GST_MEMDUMP ("buffer", info_buf.data, info_buf.size);
GST_MEMDUMP ("expected", info_expected.data, info_expected.size);
fail_unless_equals_uint64 (info_buf.size, info_expected.size);
fail_unless_equals_int (memcmp (info_buf.data, info_expected.data,
info_buf.size), 0);
gst_buffer_unmap (buf, &info_buf);
gst_buffer_unmap (expected, &info_expected);
}
static gboolean
sink_event_func (GstPad * pad, GstObject * parent, GstEvent * event)
{
GList **expected = GST_PAD_ELEMENT_PRIVATE (pad), *l;
GstEvent *exp;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:{
GstCaps *recvcaps, *expectcaps;
l = g_list_first (*expected);
exp = GST_EVENT (l->data);
gst_event_parse_caps (event, &recvcaps);
gst_event_parse_caps (exp, &expectcaps);
fail_unless (gst_caps_is_equal (recvcaps, expectcaps));
break;
}
case GST_EVENT_SEGMENT:{
const GstSegment *recvseg, *expectseg;
l = g_list_last (*expected);
exp = GST_EVENT (l->data);
gst_event_parse_segment (event, &recvseg);
gst_event_parse_segment (exp, &expectseg);
fail_unless_equals_uint64 (recvseg->position, expectseg->position);
break;
}
default:
break;
}
return gst_pad_event_default (pad, parent, event);
}
static void
test_videoframe_audiolevel_generic (void)
{
GstElement *alevel;
GstPad *asink, *vsink, *asrc, *vsrc, *aoutput_sink, *voutput_sink;
GThread *athread, *vthread;
GstBus *bus;
guint i;
got_eos = FALSE;
audio_buffer_count = 0;
video_buffer_count = 0;
num_msgs = 0;
g_queue_init (&v_timestamp_q);
g_queue_init (&msg_timestamp_q);
alevel = gst_element_factory_make ("videoframe-audiolevel", NULL);
fail_unless (alevel != NULL);
bus = gst_bus_new ();
gst_element_set_bus (alevel, bus);
gst_bus_set_sync_handler (bus, on_message, NULL, NULL);
asink = gst_element_get_static_pad (alevel, "asink");
fail_unless (asink != NULL);
vsink = gst_element_get_static_pad (alevel, "vsink");
fail_unless (vsink != NULL);
asrc = gst_element_get_static_pad (alevel, "asrc");
aoutput_sink = gst_pad_new ("sink", GST_PAD_SINK);
fail_unless (aoutput_sink != NULL);
fail_unless (gst_pad_link (asrc, aoutput_sink) == GST_PAD_LINK_OK);
vsrc = gst_element_get_static_pad (alevel, "vsrc");
voutput_sink = gst_pad_new ("sink", GST_PAD_SINK);
fail_unless (voutput_sink != NULL);
fail_unless (gst_pad_link (vsrc, voutput_sink) == GST_PAD_LINK_OK);
gst_pad_set_chain_function (aoutput_sink, output_achain);
gst_pad_set_event_function (aoutput_sink, output_aevent);
gst_pad_set_chain_function (voutput_sink, output_vchain);
gst_pad_set_event_function (voutput_sink, output_vevent);
gst_pad_set_active (aoutput_sink, TRUE);
gst_pad_set_active (voutput_sink, TRUE);
fail_unless (gst_element_set_state (alevel,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS);
athread = g_thread_new ("athread", (GThreadFunc) push_abuffers, asink);
vthread = g_thread_new ("vthread", (GThreadFunc) push_vbuffers, vsink);
g_thread_join (vthread);
g_thread_join (athread);
fail_unless (got_eos);
fail_unless_equals_int (audio_buffer_count, n_abuffers);
fail_unless_equals_int (video_buffer_count, n_vbuffers);
if (!long_video)
fail_unless_equals_int (num_msgs, n_vbuffers);
fail_unless_equals_int (g_queue_get_length (&v_timestamp_q), n_vbuffers);
/* num_msgs is equal to n_vbuffers except in the case of long_video */
fail_unless_equals_int (g_queue_get_length (&msg_timestamp_q), num_msgs);
for (i = 0; i < g_queue_get_length (&msg_timestamp_q); i++) {
GstClockTime *vt = g_queue_pop_head (&v_timestamp_q);
GstClockTime *mt = g_queue_pop_head (&msg_timestamp_q);
fail_unless (vt != NULL);
fail_unless (mt != NULL);
if (!video_gaps && !video_overlaps && !early_video)
fail_unless_equals_uint64 (*vt, *mt);
g_free (vt);
g_free (mt);
}
/* teardown */
gst_element_set_state (alevel, GST_STATE_NULL);
gst_bus_set_flushing (bus, TRUE);
gst_object_unref (bus);
g_queue_foreach (&v_timestamp_q, (GFunc) g_free, NULL);
g_queue_foreach (&msg_timestamp_q, (GFunc) g_free, NULL);
g_queue_clear (&v_timestamp_q);
g_queue_clear (&msg_timestamp_q);
gst_pad_unlink (asrc, aoutput_sink);
gst_object_unref (asrc);
gst_pad_unlink (vsrc, voutput_sink);
gst_object_unref (vsrc);
gst_object_unref (asink);
gst_object_unref (vsink);
gst_pad_set_active (aoutput_sink, FALSE);
gst_object_unref (aoutput_sink);
gst_pad_set_active (voutput_sink, FALSE);
gst_object_unref (voutput_sink);
gst_object_unref (alevel);
}
void test_more()
{
GstElement *videorate;
GstBuffer *first, *second, *third, *outbuffer;
GList *l;
GstCaps *caps;
GRand *rand;
videorate = setup_videorate ();
fail_unless (gst_element_set_state (videorate,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
assert_videorate_stats (videorate, "creation", 0, 0, 0, 0);
rand = g_rand_new ();
/* first buffer */
first = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (first) = 0;
/* it shouldn't matter what the offsets are, videorate produces perfect
streams */
GST_BUFFER_OFFSET (first) = g_rand_int (rand);
GST_BUFFER_OFFSET_END (first) = g_rand_int (rand);
memset (GST_BUFFER_DATA (first), 1, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (first, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (first, "first", 1);
gst_buffer_ref (first);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, first) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (first, "first", 2);
fail_unless_equals_int (g_list_length (buffers), 0);
assert_videorate_stats (videorate, "first buffer", 1, 0, 0, 0);
/* second buffer; inbetween second and third output frame's timestamp */
second = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (second) = GST_SECOND * 3 / 50;
GST_BUFFER_OFFSET (first) = g_rand_int (rand);
GST_BUFFER_OFFSET_END (first) = g_rand_int (rand);
memset (GST_BUFFER_DATA (second), 2, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (second, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (second, "second", 1);
gst_buffer_ref (second);
/* pushing gives away one of my references ... */
fail_unless (gst_pad_push (mysrcpad, second) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (second, "second", 2);
/* ... and the first one is pushed out, with timestamp 0 */
fail_unless_equals_int (g_list_length (buffers), 1);
assert_videorate_stats (videorate, "second buffer", 2, 1, 0, 0);
ASSERT_BUFFER_REFCOUNT (first, "first", 2);
outbuffer = buffers->data;
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (outbuffer), 0);
/* third buffer */
third = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (third) = GST_SECOND * 12 / 50;
GST_BUFFER_OFFSET (first) = g_rand_int (rand);
GST_BUFFER_OFFSET_END (first) = g_rand_int (rand);
memset (GST_BUFFER_DATA (third), 3, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (third, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (third, "third", 1);
gst_buffer_ref (third);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, third) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (third, "third", 2);
/* submitting the third buffer has triggered flushing of three more frames */
assert_videorate_stats (videorate, "third buffer", 3, 4, 0, 2);
/* check timestamp and source correctness */
l = buffers;
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (l->data), 0);
fail_unless_equals_int (GST_BUFFER_DATA (l->data)[0], 1);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET (l->data), 0);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET_END (l->data), 1);
l = g_list_next (l);
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (l->data), GST_SECOND / 25);
fail_unless_equals_int (GST_BUFFER_DATA (l->data)[0], 2);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET (l->data), 1);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET_END (l->data), 2);
l = g_list_next (l);
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (l->data),
GST_SECOND * 2 / 25);
fail_unless_equals_int (GST_BUFFER_DATA (l->data)[0], 2);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET (l->data), 2);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET_END (l->data), 3);
l = g_list_next (l);
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (l->data),
GST_SECOND * 3 / 25);
fail_unless_equals_int (GST_BUFFER_DATA (l->data)[0], 2);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET (l->data), 3);
fail_unless_equals_uint64 (GST_BUFFER_OFFSET_END (l->data), 4);
fail_unless_equals_int (g_list_length (buffers), 4);
/* one held by us, three held by each output frame taken from the second */
ASSERT_BUFFER_REFCOUNT (second, "second", 4);
/* now send EOS */
fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()));
/* submitting eos should flush out two more frames for tick 8 and 10 */
/* FIXME: right now it only flushes out one, so out is 5 instead of 6 ! */
assert_videorate_stats (videorate, "eos", 3, 5, 0, 2);
fail_unless_equals_int (g_list_length (buffers), 5);
/* cleanup */
g_rand_free (rand);
gst_buffer_unref (first);
gst_buffer_unref (second);
gst_buffer_unref (third);
cleanup_videorate (videorate);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
/* this tests that the output is a correct discontinuous stream
* if the input is; ie input drops in time come out the same way */
static void
test_discont_stream_instance (int inrate, int outrate, int samples,
int numbuffers)
{
GstElement *audioresample;
GstBuffer *inbuffer, *outbuffer;
GstCaps *caps;
GstClockTime ints;
int i, j;
GstMapInfo map;
gint16 *p;
GST_DEBUG ("inrate:%d outrate:%d samples:%d numbuffers:%d",
inrate, outrate, samples, numbuffers);
audioresample =
setup_audioresample (2, 3, inrate, outrate, GST_AUDIO_NE (S16));
caps = gst_pad_get_current_caps (mysrcpad);
fail_unless (gst_caps_is_fixed (caps));
fail_unless (gst_element_set_state (audioresample,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
for (j = 1; j <= numbuffers; ++j) {
inbuffer = gst_buffer_new_and_alloc (samples * 4);
GST_BUFFER_DURATION (inbuffer) = samples * GST_SECOND / inrate;
/* "drop" half the buffers */
ints = GST_BUFFER_DURATION (inbuffer) * 2 * (j - 1);
GST_BUFFER_TIMESTAMP (inbuffer) = ints;
GST_BUFFER_OFFSET (inbuffer) = (j - 1) * 2 * samples;
GST_BUFFER_OFFSET_END (inbuffer) = j * 2 * samples + samples;
gst_buffer_map (inbuffer, &map, GST_MAP_WRITE);
p = (gint16 *) map.data;
/* create a 16 bit signed ramp */
for (i = 0; i < samples; ++i) {
*p = -32767 + i * (65535 / samples);
++p;
*p = -32767 + i * (65535 / samples);
++p;
}
gst_buffer_unmap (inbuffer, &map);
GST_DEBUG ("Sending Buffer time:%" G_GUINT64_FORMAT " duration:%"
G_GINT64_FORMAT " discont:%d offset:%" G_GUINT64_FORMAT " offset_end:%"
G_GUINT64_FORMAT, GST_BUFFER_TIMESTAMP (inbuffer),
GST_BUFFER_DURATION (inbuffer), GST_BUFFER_IS_DISCONT (inbuffer),
GST_BUFFER_OFFSET (inbuffer), GST_BUFFER_OFFSET_END (inbuffer));
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
/* check if the timestamp of the pushed buffer matches the incoming one */
outbuffer = g_list_nth_data (buffers, g_list_length (buffers) - 1);
fail_if (outbuffer == NULL);
fail_unless_equals_uint64 (ints, GST_BUFFER_TIMESTAMP (outbuffer));
GST_DEBUG ("Got Buffer time:%" G_GUINT64_FORMAT " duration:%"
G_GINT64_FORMAT " discont:%d offset:%" G_GUINT64_FORMAT " offset_end:%"
G_GUINT64_FORMAT, GST_BUFFER_TIMESTAMP (outbuffer),
GST_BUFFER_DURATION (outbuffer), GST_BUFFER_IS_DISCONT (outbuffer),
GST_BUFFER_OFFSET (outbuffer), GST_BUFFER_OFFSET_END (outbuffer));
if (j > 1) {
fail_unless (GST_BUFFER_IS_DISCONT (outbuffer),
"expected discont for buffer #%d", j);
}
}
/* cleanup */
gst_caps_unref (caps);
cleanup_audioresample (audioresample);
}
static void
do_perfect_stream_test (guint rate, guint width, gdouble drop_probability,
gdouble inject_probability)
{
GstElement *pipe, *src, *conv, *filter, *injector, *audiorate, *sink;
GstMessage *msg;
GstCaps *caps;
GstPad *srcpad;
GList *l, *bufs = NULL;
GstClockTime next_time = GST_CLOCK_TIME_NONE;
guint64 next_offset = GST_BUFFER_OFFSET_NONE;
caps = gst_caps_new_simple ("audio/x-raw-int", "rate", G_TYPE_INT,
rate, "width", G_TYPE_INT, width, NULL);
GST_INFO ("-------- drop=%.0f%% caps = %" GST_PTR_FORMAT " ---------- ",
drop_probability * 100.0, caps);
g_assert (drop_probability >= 0.0 && drop_probability <= 1.0);
g_assert (inject_probability >= 0.0 && inject_probability <= 1.0);
g_assert (width > 0 && (width % 8) == 0);
pipe = gst_pipeline_new ("pipeline");
fail_unless (pipe != NULL);
src = gst_element_factory_make ("audiotestsrc", "audiotestsrc");
fail_unless (src != NULL);
g_object_set (src, "num-buffers", 100, NULL);
conv = gst_element_factory_make ("audioconvert", "audioconvert");
fail_unless (conv != NULL);
filter = gst_element_factory_make ("capsfilter", "capsfilter");
fail_unless (filter != NULL);
g_object_set (filter, "caps", caps, NULL);
injector_inject_probability = inject_probability;
injector = GST_ELEMENT (g_object_new (test_injector_get_type (), NULL));
srcpad = gst_element_get_pad (injector, "src");
fail_unless (srcpad != NULL);
gst_pad_add_buffer_probe (srcpad, G_CALLBACK (probe_cb), &drop_probability);
gst_object_unref (srcpad);
audiorate = gst_element_factory_make ("audiorate", "audiorate");
fail_unless (audiorate != NULL);
sink = gst_element_factory_make ("fakesink", "fakesink");
fail_unless (sink != NULL);
g_object_set (sink, "signal-handoffs", TRUE, NULL);
g_signal_connect (sink, "handoff", G_CALLBACK (got_buf), &bufs);
gst_bin_add_many (GST_BIN (pipe), src, conv, filter, injector, audiorate,
sink, NULL);
gst_element_link_many (src, conv, filter, injector, audiorate, sink, NULL);
fail_unless_equals_int (gst_element_set_state (pipe, GST_STATE_PLAYING),
GST_STATE_CHANGE_ASYNC);
fail_unless_equals_int (gst_element_get_state (pipe, NULL, NULL, -1),
GST_STATE_CHANGE_SUCCESS);
msg = gst_bus_poll (GST_ELEMENT_BUS (pipe),
GST_MESSAGE_EOS | GST_MESSAGE_ERROR, -1);
fail_unless_equals_string (GST_MESSAGE_TYPE_NAME (msg), "eos");
for (l = bufs; l != NULL; l = l->next) {
GstBuffer *buf = GST_BUFFER (l->data);
guint num_samples;
fail_unless (GST_BUFFER_TIMESTAMP_IS_VALID (buf));
fail_unless (GST_BUFFER_DURATION_IS_VALID (buf));
fail_unless (GST_BUFFER_OFFSET_IS_VALID (buf));
fail_unless (GST_BUFFER_OFFSET_END_IS_VALID (buf));
GST_LOG ("buffer: ts=%" GST_TIME_FORMAT ", end_ts=%" GST_TIME_FORMAT
" off=%" G_GINT64_FORMAT ", end_off=%" G_GINT64_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf)),
GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET_END (buf));
if (GST_CLOCK_TIME_IS_VALID (next_time)) {
fail_unless_equals_uint64 (next_time, GST_BUFFER_TIMESTAMP (buf));
}
if (next_offset != GST_BUFFER_OFFSET_NONE) {
fail_unless_equals_uint64 (next_offset, GST_BUFFER_OFFSET (buf));
}
/* check buffer size for sanity */
fail_unless_equals_int (GST_BUFFER_SIZE (buf) % (width / 8), 0);
/* check there is actually as much data as there should be */
num_samples = GST_BUFFER_OFFSET_END (buf) - GST_BUFFER_OFFSET (buf);
fail_unless_equals_int (GST_BUFFER_SIZE (buf), num_samples * (width / 8));
next_time = GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf);
next_offset = GST_BUFFER_OFFSET_END (buf);
}
gst_message_unref (msg);
gst_element_set_state (pipe, GST_STATE_NULL);
gst_object_unref (pipe);
g_list_foreach (bufs, (GFunc) gst_mini_object_unref, NULL);
g_list_free (bufs);
gst_caps_unref (caps);
}
/* frames at 1, 0, 2 -> second one should be ignored */
void test_wrong_order_from_zero()
{
GstElement *videorate;
GstBuffer *first, *second, *third, *outbuffer;
GstCaps *caps;
videorate = setup_videorate ();
fail_unless (gst_element_set_state (videorate,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
assert_videorate_stats (videorate, "start", 0, 0, 0, 0);
/* first buffer */
first = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (first) = GST_SECOND;
memset (GST_BUFFER_DATA (first), 0, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (first, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (first, "first", 1);
gst_buffer_ref (first);
GST_DEBUG ("pushing first buffer");
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, first) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (first, "first", 2);
fail_unless_equals_int (g_list_length (buffers), 0);
assert_videorate_stats (videorate, "first", 1, 0, 0, 0);
/* second buffer */
second = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (second) = 0;
memset (GST_BUFFER_DATA (second), 0, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (second, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (second, "second", 1);
gst_buffer_ref (second);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, second) == GST_FLOW_OK);
/* ... and it is now dropped because it is too old */
ASSERT_BUFFER_REFCOUNT (second, "second", 1);
fail_unless_equals_int (g_list_length (buffers), 0);
/* ... and the first one is still there */
assert_videorate_stats (videorate, "second", 2, 0, 1, 0);
ASSERT_BUFFER_REFCOUNT (first, "first", 2);
/* third buffer */
third = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (third) = 2 * GST_SECOND;
memset (GST_BUFFER_DATA (third), 0, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (third, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (third, "third", 1);
gst_buffer_ref (third);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, third) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (third, "third", 2);
/* and now the first one should be pushed once and dupped 24 + 13 times, to
* reach the half point between 1 s (first) and 2 s (third) */
fail_unless_equals_int (g_list_length (buffers), 38);
ASSERT_BUFFER_REFCOUNT (first, "first", 39);
ASSERT_BUFFER_REFCOUNT (second, "second", 1);
ASSERT_BUFFER_REFCOUNT (third, "third", 2);
assert_videorate_stats (videorate, "third", 3, 38, 1, 37);
/* verify last buffer */
outbuffer = g_list_last (buffers)->data;
fail_unless (GST_IS_BUFFER (outbuffer));
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (outbuffer),
GST_SECOND * 37 / 25);
/* cleanup */
gst_buffer_unref (first);
gst_buffer_unref (second);
gst_buffer_unref (third);
cleanup_videorate (videorate);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static GstFlowReturn
gst_test_http_src_create (GstBaseSrc * basesrc, guint64 offset,
guint length, GstBuffer ** retbuf)
{
GstTestHTTPSrc *src = GST_TEST_HTTP_SRC (basesrc);
guint bytes_read;
GstFlowReturn ret = GST_FLOW_OK;
guint blocksize;
fail_unless (gst_test_http_src_callbacks != NULL);
fail_unless (gst_test_http_src_callbacks->src_create != NULL);
GST_OBJECT_LOCK (src);
blocksize = basesrc->blocksize;
GST_OBJECT_UNLOCK (src);
g_mutex_lock (&src->mutex);
GST_DEBUG ("gst_test_http_src_create feeding from %" G_GUINT64_FORMAT,
src->position);
if (src->uri == NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
g_mutex_unlock (&src->mutex);
return GST_FLOW_ERROR;
}
if (src->input.status_code < 200 || src->input.status_code >= 300) {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, ("%s",
"Generated requested error"), ("%s (%d), URL: %s, Redirect to: %s",
"Generated requested error", src->input.status_code, src->uri,
GST_STR_NULL (NULL)));
g_mutex_unlock (&src->mutex);
return GST_FLOW_ERROR;
}
if (src->http_method == METHOD_INVALID) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, ("%s",
"Invalid HTTP method"), ("%s (%s), URL: %s",
"Invalid HTTP method", src->http_method_name, src->uri));
g_mutex_unlock (&src->mutex);
return GST_FLOW_ERROR;
} else if (src->http_method == METHOD_HEAD) {
ret = GST_FLOW_EOS;
goto http_events;
}
fail_unless_equals_uint64 (offset, src->position);
bytes_read = MIN ((src->segment_end - src->position), blocksize);
if (bytes_read == 0) {
ret = GST_FLOW_EOS;
goto http_events;
}
ret = gst_test_http_src_callbacks->src_create (src,
offset, bytes_read, retbuf,
src->input.context, gst_test_http_src_callback_user_data);
if (ret != GST_FLOW_OK) {
goto http_events;
}
GST_BUFFER_OFFSET (*retbuf) = src->position;
GST_BUFFER_OFFSET_END (*retbuf) = src->position + bytes_read;
src->position += bytes_read;
http_events:
if (src->http_headers_event) {
gst_pad_push_event (GST_BASE_SRC_PAD (src), src->http_headers_event);
src->http_headers_event = NULL;
}
if (src->duration_changed) {
src->duration_changed = FALSE;
gst_element_post_message (GST_ELEMENT (src),
gst_message_new_duration_changed (GST_OBJECT (src)));
}
g_mutex_unlock (&src->mutex);
return ret;
}
/* send frames with 0, 1, 2, 0 seconds */
void test_wrong_order()
{
GstElement *videorate;
GstBuffer *first, *second, *third, *fourth, *outbuffer;
GstCaps *caps;
videorate = setup_videorate ();
fail_unless (gst_element_set_state (videorate,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
assert_videorate_stats (videorate, "start", 0, 0, 0, 0);
/* first buffer */
first = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (first) = 0;
memset (GST_BUFFER_DATA (first), 0, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (first, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (first, "first", 1);
gst_buffer_ref (first);
GST_DEBUG ("pushing first buffer");
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, first) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (first, "first", 2);
fail_unless_equals_int (g_list_length (buffers), 0);
assert_videorate_stats (videorate, "first", 1, 0, 0, 0);
/* second buffer */
second = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (second) = GST_SECOND;
memset (GST_BUFFER_DATA (second), 0, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (second, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (second, "second", 1);
gst_buffer_ref (second);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, second) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (second, "second", 2);
/* and it created 13 output buffers as copies of the first frame */
fail_unless_equals_int (g_list_length (buffers), 13);
assert_videorate_stats (videorate, "second", 2, 13, 0, 12);
ASSERT_BUFFER_REFCOUNT (first, "first", 14);
/* third buffer */
third = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (third) = 2 * GST_SECOND;
memset (GST_BUFFER_DATA (third), 0, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (third, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (third, "third", 1);
gst_buffer_ref (third);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, third) == GST_FLOW_OK);
/* ... and it is now stuck inside videorate */
ASSERT_BUFFER_REFCOUNT (third, "third", 2);
/* submitting a frame with 2 seconds triggers output of 25 more frames */
fail_unless_equals_int (g_list_length (buffers), 38);
ASSERT_BUFFER_REFCOUNT (first, "first", 14);
ASSERT_BUFFER_REFCOUNT (second, "second", 26);
/* three frames submitted; two of them output as is, and 36 duplicated */
assert_videorate_stats (videorate, "third", 3, 38, 0, 36);
/* fourth buffer */
fourth = gst_buffer_new_and_alloc (4);
GST_BUFFER_TIMESTAMP (fourth) = 0;
memset (GST_BUFFER_DATA (fourth), 0, 4);
caps = gst_caps_from_string (VIDEO_CAPS_STRING);
gst_buffer_set_caps (fourth, caps);
gst_caps_unref (caps);
ASSERT_BUFFER_REFCOUNT (fourth, "fourth", 1);
gst_buffer_ref (fourth);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, fourth) == GST_FLOW_OK);
/* ... and it is dropped */
ASSERT_BUFFER_REFCOUNT (fourth, "fourth", 1);
fail_unless_equals_int (g_list_length (buffers), 38);
ASSERT_BUFFER_REFCOUNT (first, "first", 14);
ASSERT_BUFFER_REFCOUNT (second, "second", 26);
assert_videorate_stats (videorate, "fourth", 4, 38, 1, 36);
/* verify last buffer */
outbuffer = g_list_last (buffers)->data;
fail_unless (GST_IS_BUFFER (outbuffer));
fail_unless_equals_uint64 (GST_BUFFER_TIMESTAMP (outbuffer),
GST_SECOND * 37 / 25);
/* cleanup */
gst_buffer_unref (first);
gst_buffer_unref (second);
gst_buffer_unref (third);
gst_buffer_unref (fourth);
cleanup_videorate (videorate);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
