mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-19 08:11:16 +00:00
3f184c3abc
In many cases the unistd.h includes weren't actually needed. Don't build tests that need it on windows with MSVC (multifdsink, multisocketsink, pipelines/tcp). Preparation for making tests work on Windows with MSVC.
1162 lines
39 KiB
C
1162 lines
39 KiB
C
/* GStreamer unit tests for textoverlay
|
|
*
|
|
* Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <gst/check/gstcheck.h>
|
|
#include <gst/video/video-overlay-composition.h>
|
|
|
|
#define I420_Y_ROWSTRIDE(width) (GST_ROUND_UP_4(width))
|
|
#define I420_U_ROWSTRIDE(width) (GST_ROUND_UP_8(width)/2)
|
|
#define I420_V_ROWSTRIDE(width) ((GST_ROUND_UP_8(I420_Y_ROWSTRIDE(width)))/2)
|
|
|
|
#define I420_Y_OFFSET(w,h) (0)
|
|
#define I420_U_OFFSET(w,h) (I420_Y_OFFSET(w,h)+(I420_Y_ROWSTRIDE(w)*GST_ROUND_UP_2(h)))
|
|
#define I420_V_OFFSET(w,h) (I420_U_OFFSET(w,h)+(I420_U_ROWSTRIDE(w)*GST_ROUND_UP_2(h)/2))
|
|
|
|
#define I420_SIZE(w,h) (I420_V_OFFSET(w,h)+(I420_V_ROWSTRIDE(w)*GST_ROUND_UP_2(h)/2))
|
|
|
|
#define WIDTH 240
|
|
#define HEIGHT 120
|
|
|
|
/* For ease of programming we use globals to keep refs for our floating
|
|
* src and sink pads we create; otherwise we always have to do get_pad,
|
|
* get_peer, and then remove references in every test function */
|
|
static GstPad *myvideosrcpad, *mytextsrcpad, *mysinkpad;
|
|
|
|
#define VIDEO_CAPS_STRING \
|
|
"video/x-raw, " \
|
|
"format = (string) I420, " \
|
|
"framerate = (fraction) 1/1, " \
|
|
"width = (int) 240, " \
|
|
"height = (int) 120"
|
|
|
|
#define VIDEO_CAPS_TEMPLATE_STRING \
|
|
"video/x-raw, " \
|
|
"format = (string) I420"
|
|
|
|
#define VIDEO_CAPS_TEMPLATE_WITH_FEATURE_STRING \
|
|
"video/x-raw(" GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY ", " \
|
|
GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION "), " \
|
|
"format = (string) I420;" \
|
|
"video/x-raw, " \
|
|
"format = (string) I420;"
|
|
|
|
#define UNSUPPORTED_VIDEO_CAPS_STRING \
|
|
"video/x-raw(" GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META "), " \
|
|
"format = (string) I420, " \
|
|
"framerate = (fraction) 1/1, " \
|
|
"width = (int) 240, " \
|
|
"height = (int) 120"
|
|
|
|
#define UNSUPPORTED_VIDEO_CAPS_TEMPLATE_STRING \
|
|
"video/x-raw(" GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META "), " \
|
|
"format = (string) I420"
|
|
|
|
#define UNSUPPORTED_VIDEO_CAPS_TEMPLATE_WITH_FEATURE_STRING \
|
|
"video/x-raw(" GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META "," \
|
|
GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION "), " \
|
|
"format = (string) I420;" \
|
|
"video/x-raw(" GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META "), " \
|
|
"format = (string) I420"
|
|
|
|
static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS (VIDEO_CAPS_TEMPLATE_STRING)
|
|
);
|
|
|
|
static GstStaticPadTemplate sinktemplate_with_features =
|
|
GST_STATIC_PAD_TEMPLATE ("sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS (VIDEO_CAPS_TEMPLATE_WITH_FEATURE_STRING)
|
|
);
|
|
|
|
static GstStaticPadTemplate text_srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS ("text/x-raw, format=utf8")
|
|
);
|
|
|
|
static GstStaticPadTemplate video_srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS (VIDEO_CAPS_TEMPLATE_STRING)
|
|
);
|
|
|
|
static GstStaticPadTemplate unsupported_sinktemplate_with_features =
|
|
GST_STATIC_PAD_TEMPLATE ("sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS (UNSUPPORTED_VIDEO_CAPS_TEMPLATE_WITH_FEATURE_STRING)
|
|
);
|
|
|
|
static GstStaticPadTemplate sinktemplate_any = GST_STATIC_PAD_TEMPLATE ("sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS_ANY);
|
|
|
|
static GstStaticPadTemplate unsupported_video_srctemplate =
|
|
GST_STATIC_PAD_TEMPLATE ("src",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS (UNSUPPORTED_VIDEO_CAPS_TEMPLATE_STRING)
|
|
);
|
|
|
|
static void
|
|
gst_check_setup_events_textoverlay (GstPad * srcpad, GstElement * element,
|
|
GstCaps * caps, GstFormat format, const gchar * stream_id)
|
|
{
|
|
GstSegment segment;
|
|
|
|
gst_segment_init (&segment, format);
|
|
|
|
fail_unless (gst_pad_push_event (srcpad,
|
|
gst_event_new_stream_start (stream_id)));
|
|
if (caps)
|
|
fail_unless (gst_pad_push_event (srcpad, gst_event_new_caps (caps)));
|
|
fail_unless (gst_pad_push_event (srcpad, gst_event_new_segment (&segment)));
|
|
}
|
|
|
|
|
|
static gboolean
|
|
sink_query_handler (GstPad * pad, GstObject * parent, GstQuery * query)
|
|
{
|
|
gboolean ret = FALSE;
|
|
GstQueryType type = GST_QUERY_TYPE (query);
|
|
|
|
switch (type) {
|
|
case GST_QUERY_ALLOCATION:{
|
|
gst_query_add_allocation_meta (query,
|
|
GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, NULL);
|
|
|
|
ret = TRUE;
|
|
|
|
break;
|
|
}
|
|
default:{
|
|
ret = gst_pad_query_default (pad, parent, query);
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* much like gst_check_setup_src_pad(), but with possibility to give a hint
|
|
* which sink template of the element to use, if there are multiple ones */
|
|
static GstPad *
|
|
notgst_check_setup_src_pad2 (GstElement * element,
|
|
GstStaticPadTemplate * template, GstCaps * caps,
|
|
const gchar * sink_template_name)
|
|
{
|
|
GstPad *srcpad, *sinkpad;
|
|
|
|
if (sink_template_name == NULL)
|
|
sink_template_name = "sink";
|
|
|
|
/* sending pad */
|
|
srcpad = gst_pad_new_from_static_template (template, "src");
|
|
GST_DEBUG_OBJECT (element, "setting up sending pad %p", srcpad);
|
|
fail_if (srcpad == NULL, "Could not create a srcpad");
|
|
ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1);
|
|
|
|
if (!(sinkpad = gst_element_get_static_pad (element, sink_template_name)))
|
|
sinkpad = gst_element_get_request_pad (element, sink_template_name);
|
|
fail_if (sinkpad == NULL, "Could not get sink pad from %s",
|
|
GST_ELEMENT_NAME (element));
|
|
ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 2);
|
|
if (caps)
|
|
fail_unless (gst_pad_set_caps (srcpad, caps));
|
|
fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK,
|
|
"Could not link source and %s sink pads", GST_ELEMENT_NAME (element));
|
|
gst_object_unref (sinkpad); /* because we got it higher up */
|
|
ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 1);
|
|
|
|
return srcpad;
|
|
}
|
|
|
|
static void
|
|
notgst_check_teardown_src_pad2 (GstElement * element,
|
|
const gchar * sink_template_name)
|
|
{
|
|
GstPad *srcpad, *sinkpad;
|
|
|
|
if (sink_template_name == NULL)
|
|
sink_template_name = "sink";
|
|
|
|
/* clean up floating src pad */
|
|
if (!(sinkpad = gst_element_get_static_pad (element, sink_template_name)))
|
|
sinkpad = gst_element_get_request_pad (element, sink_template_name);
|
|
ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 2);
|
|
srcpad = gst_pad_get_peer (sinkpad);
|
|
|
|
gst_pad_unlink (srcpad, sinkpad);
|
|
|
|
/* pad refs held by both creator and this function (through _get) */
|
|
ASSERT_OBJECT_REFCOUNT (sinkpad, "element sinkpad", 2);
|
|
gst_object_unref (sinkpad);
|
|
/* one more ref is held by element itself */
|
|
|
|
/* pad refs held by both creator and this function (through _get_peer) */
|
|
ASSERT_OBJECT_REFCOUNT (srcpad, "check srcpad", 2);
|
|
gst_object_unref (srcpad);
|
|
gst_object_unref (srcpad);
|
|
}
|
|
|
|
static GstElement *
|
|
setup_textoverlay_with_templates (GstStaticPadTemplate * srcpad_template,
|
|
GstStaticPadTemplate * textpad_template,
|
|
GstStaticPadTemplate * sinkpad_template, gboolean enable_allocation_query)
|
|
{
|
|
GstElement *textoverlay;
|
|
|
|
GST_DEBUG ("setup_textoverlay");
|
|
textoverlay = gst_check_setup_element ("textoverlay");
|
|
mysinkpad = gst_check_setup_sink_pad (textoverlay, sinkpad_template);
|
|
|
|
if (enable_allocation_query) {
|
|
GST_PAD_SET_PROXY_ALLOCATION (mysinkpad);
|
|
gst_pad_set_query_function (mysinkpad, sink_query_handler);
|
|
}
|
|
|
|
myvideosrcpad =
|
|
notgst_check_setup_src_pad2 (textoverlay, srcpad_template, NULL,
|
|
"video_sink");
|
|
|
|
if (textpad_template) {
|
|
mytextsrcpad =
|
|
notgst_check_setup_src_pad2 (textoverlay, textpad_template, NULL,
|
|
"text_sink");
|
|
gst_pad_set_active (mytextsrcpad, TRUE);
|
|
} else {
|
|
mytextsrcpad = NULL;
|
|
}
|
|
|
|
gst_pad_set_active (myvideosrcpad, TRUE);
|
|
gst_pad_set_active (mysinkpad, TRUE);
|
|
|
|
return textoverlay;
|
|
}
|
|
|
|
static GstElement *
|
|
setup_textoverlay (gboolean video_only_no_text)
|
|
{
|
|
GstStaticPadTemplate *srcpad_template = NULL;
|
|
GstStaticPadTemplate *textpad_template = NULL;
|
|
GstStaticPadTemplate *sinkpad_template = NULL;
|
|
|
|
srcpad_template = &video_srctemplate;
|
|
if (!video_only_no_text)
|
|
textpad_template = &text_srctemplate;
|
|
sinkpad_template = &sinktemplate;
|
|
|
|
return setup_textoverlay_with_templates (srcpad_template,
|
|
textpad_template, sinkpad_template, FALSE);
|
|
}
|
|
|
|
static gboolean
|
|
buffer_is_all_black (GstBuffer * buf, GstCaps * caps)
|
|
{
|
|
GstStructure *s;
|
|
gint x, y, w, h;
|
|
GstMapInfo map;
|
|
|
|
fail_unless (buf != NULL);
|
|
fail_unless (caps != NULL);
|
|
s = gst_caps_get_structure (caps, 0);
|
|
fail_unless (s != NULL);
|
|
fail_unless (gst_structure_get_int (s, "width", &w));
|
|
fail_unless (gst_structure_get_int (s, "height", &h));
|
|
|
|
gst_buffer_map (buf, &map, GST_MAP_READ);
|
|
for (y = 0; y < h; ++y) {
|
|
guint8 *ptr = map.data + (y * GST_ROUND_UP_4 (w));
|
|
|
|
for (x = 0; x < w; ++x) {
|
|
if (ptr[x] != 0x00) {
|
|
GST_LOG ("non-black pixel (%d) at (x,y) %d,%d", ptr[x], x, y);
|
|
gst_buffer_unmap (buf, &map);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
gst_buffer_unmap (buf, &map);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static GstCaps *
|
|
create_video_caps (const gchar * caps_string)
|
|
{
|
|
GstCaps *caps;
|
|
|
|
caps = gst_caps_from_string (caps_string);
|
|
fail_unless (caps != NULL);
|
|
fail_unless (gst_caps_is_fixed (caps));
|
|
|
|
return caps;
|
|
}
|
|
|
|
static GstBuffer *
|
|
create_black_buffer (GstCaps * caps)
|
|
{
|
|
GstStructure *s;
|
|
GstBuffer *buffer;
|
|
gint w, h, size;
|
|
|
|
fail_unless (caps != NULL);
|
|
|
|
s = gst_caps_get_structure (caps, 0);
|
|
fail_unless (gst_structure_get_int (s, "width", &w));
|
|
fail_unless (gst_structure_get_int (s, "height", &h));
|
|
|
|
GST_LOG ("creating buffer (%dx%d)", w, h);
|
|
|
|
size = I420_SIZE (w, h);
|
|
buffer = gst_buffer_new_and_alloc (size);
|
|
/* we're only checking the Y plane later, so just zero it all out,
|
|
* even if it's not the blackest black there is */
|
|
gst_buffer_memset (buffer, 0, 0, size);
|
|
|
|
/* double check to make sure it's been created right */
|
|
fail_unless (buffer_is_all_black (buffer, caps));
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static GstBuffer *
|
|
create_text_buffer (const gchar * txt, GstClockTime ts, GstClockTime duration)
|
|
{
|
|
GstBuffer *buffer;
|
|
guint txt_len;
|
|
|
|
fail_unless (txt != NULL);
|
|
|
|
txt_len = strlen (txt);
|
|
|
|
buffer = gst_buffer_new_and_alloc (txt_len);
|
|
gst_buffer_fill (buffer, 0, txt, txt_len);
|
|
|
|
GST_BUFFER_TIMESTAMP (buffer) = ts;
|
|
GST_BUFFER_DURATION (buffer) = duration;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static gboolean
|
|
_test_textoverlay_check_caps_has_feature (GstElement * textoverlay,
|
|
const gchar * padname, const gchar * feature)
|
|
{
|
|
GstPad *pad;
|
|
GstCaps *caps;
|
|
GstCapsFeatures *f;
|
|
gboolean ret;
|
|
|
|
pad = gst_element_get_static_pad (textoverlay, padname);
|
|
fail_unless (pad != NULL);
|
|
|
|
caps = gst_pad_get_current_caps (pad);
|
|
fail_unless (caps != NULL);
|
|
|
|
gst_object_unref (pad);
|
|
|
|
f = gst_caps_get_features (caps, 0);
|
|
if (f != NULL) {
|
|
ret = gst_caps_features_contains (f, feature);
|
|
} else {
|
|
ret = FALSE;
|
|
}
|
|
|
|
gst_caps_unref (caps);
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
cleanup_textoverlay (GstElement * textoverlay)
|
|
{
|
|
GST_DEBUG ("cleanup_textoverlay");
|
|
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
|
|
gst_element_set_state (textoverlay, GST_STATE_NULL);
|
|
gst_element_get_state (textoverlay, NULL, NULL, GST_CLOCK_TIME_NONE);
|
|
gst_pad_set_active (myvideosrcpad, FALSE);
|
|
gst_pad_set_active (mysinkpad, FALSE);
|
|
notgst_check_teardown_src_pad2 (textoverlay, "video_sink");
|
|
if (mytextsrcpad) {
|
|
notgst_check_teardown_src_pad2 (textoverlay, "text_sink");
|
|
}
|
|
gst_check_teardown_sink_pad (textoverlay);
|
|
gst_check_teardown_element (textoverlay);
|
|
}
|
|
|
|
GST_START_TEST (test_video_passthrough)
|
|
{
|
|
GstElement *textoverlay;
|
|
GstBuffer *inbuffer, *outbuffer;
|
|
GstCaps *incaps, *outcaps;
|
|
GstSegment segment;
|
|
|
|
textoverlay = setup_textoverlay (TRUE);
|
|
fail_unless (gst_element_set_state (textoverlay,
|
|
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
|
|
"could not set to playing");
|
|
|
|
incaps = create_video_caps (VIDEO_CAPS_STRING);
|
|
gst_check_setup_events_textoverlay (myvideosrcpad, textoverlay, incaps,
|
|
GST_FORMAT_TIME, "video");
|
|
inbuffer = create_black_buffer (incaps);
|
|
gst_caps_unref (incaps);
|
|
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* ========== (1) video buffer without timestamp => should be dropped ==== */
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should have been discarded as out-of-segment since it has no timestamp */
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
fail_unless_equals_int (g_list_length (buffers), 0);
|
|
|
|
/* ========== (2) buffer with 0 timestamp => simple passthrough ========== */
|
|
|
|
/* now try again, this time with timestamp (segment defaults to 0 start) */
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_CLOCK_TIME_NONE;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* text pad is not linked, timestamp is in segment, no static text to
|
|
* render, should have gone through right away without modification */
|
|
fail_unless_equals_int (g_list_length (buffers), 1);
|
|
outbuffer = GST_BUFFER_CAST (buffers->data);
|
|
fail_unless (outbuffer == inbuffer);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps));
|
|
gst_caps_unref (outcaps);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* ========== (3) buffer with 0 timestamp and no duration, with the
|
|
* segment starting from 1sec => should be discarded */
|
|
|
|
gst_segment_init (&segment, GST_FORMAT_TIME);
|
|
segment.start = 1 * GST_SECOND;
|
|
segment.stop = -1;
|
|
segment.time = 0;
|
|
gst_pad_push_event (myvideosrcpad, gst_event_new_segment (&segment));
|
|
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_CLOCK_TIME_NONE;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should have been discarded as out-of-segment */
|
|
fail_unless_equals_int (g_list_length (buffers), 0);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* ========== (4) buffer with 0 timestamp and small defined duration, with
|
|
* segment starting from 1sec => should be discarded */
|
|
|
|
gst_pad_push_event (myvideosrcpad, gst_event_new_segment (&segment));
|
|
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 10;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should have been discarded as out-of-segment since it has no timestamp */
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
fail_unless_equals_int (g_list_length (buffers), 0);
|
|
|
|
/* ========== (5) buffer partially overlapping into the segment => should
|
|
* be pushed through, but with adjusted stamp values */
|
|
|
|
gst_pad_push_event (myvideosrcpad, gst_event_new_segment (&segment));
|
|
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = GST_SECOND / 4;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should be a new buffer for the stamp fix-up */
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
fail_unless_equals_int (g_list_length (buffers), 1);
|
|
outbuffer = GST_BUFFER_CAST (buffers->data);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (outbuffer != inbuffer);
|
|
fail_unless (GST_BUFFER_TIMESTAMP (outbuffer) == GST_SECOND);
|
|
fail_unless (GST_BUFFER_DURATION (outbuffer) == (GST_SECOND / 4));
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps));
|
|
gst_caps_unref (outcaps);
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* cleanup */
|
|
cleanup_textoverlay (textoverlay);
|
|
gst_buffer_unref (inbuffer);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_video_passthrough_with_feature)
|
|
{
|
|
GstElement *textoverlay;
|
|
GstBuffer *inbuffer, *outbuffer;
|
|
GstCaps *incaps, *outcaps;
|
|
GstVideoOverlayCompositionMeta *comp_meta;
|
|
|
|
textoverlay = setup_textoverlay_with_templates (&video_srctemplate,
|
|
NULL, &sinktemplate_with_features, TRUE);
|
|
|
|
/* set static text to render */
|
|
g_object_set (textoverlay, "text", "XLX", NULL);
|
|
|
|
fail_unless (gst_element_set_state (textoverlay,
|
|
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
|
|
"could not set to playing");
|
|
|
|
incaps = create_video_caps (VIDEO_CAPS_STRING);
|
|
gst_check_setup_events_textoverlay (myvideosrcpad, textoverlay, incaps,
|
|
GST_FORMAT_TIME, "video");
|
|
inbuffer = create_black_buffer (incaps);
|
|
gst_caps_unref (incaps);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 10;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should have been dropped in favour of a new writable buffer */
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
fail_unless_equals_int (g_list_length (buffers), 1);
|
|
outbuffer = GST_BUFFER_CAST (buffers->data);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (outbuffer != inbuffer);
|
|
|
|
/* output buffer should be black */
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps) == TRUE);
|
|
gst_caps_unref (outcaps);
|
|
|
|
/* output buffer should have the composition meta */
|
|
comp_meta = gst_buffer_get_video_overlay_composition_meta (outbuffer);
|
|
fail_unless (comp_meta != NULL);
|
|
|
|
fail_unless (GST_BUFFER_TIMESTAMP (outbuffer) == 0);
|
|
fail_unless (GST_BUFFER_DURATION (outbuffer) == (GST_SECOND / 10));
|
|
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* cleanup */
|
|
cleanup_textoverlay (textoverlay);
|
|
gst_buffer_unref (inbuffer);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_video_passthrough_with_feature_and_unsupported_caps)
|
|
{
|
|
GstElement *textoverlay;
|
|
GstBuffer *inbuffer, *outbuffer;
|
|
GstCaps *incaps, *outcaps;
|
|
GstVideoOverlayCompositionMeta *comp_meta;
|
|
|
|
textoverlay =
|
|
setup_textoverlay_with_templates (&unsupported_video_srctemplate, NULL,
|
|
&unsupported_sinktemplate_with_features, TRUE);
|
|
|
|
/* set static text to render */
|
|
g_object_set (textoverlay, "text", "XLX", NULL);
|
|
|
|
fail_unless (gst_element_set_state (textoverlay,
|
|
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
|
|
"could not set to playing");
|
|
|
|
incaps = create_video_caps (UNSUPPORTED_VIDEO_CAPS_STRING);
|
|
gst_check_setup_events_textoverlay (myvideosrcpad, textoverlay, incaps,
|
|
GST_FORMAT_TIME, "video");
|
|
inbuffer = create_black_buffer (incaps);
|
|
gst_caps_unref (incaps);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 10;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should have been dropped in favour of a new writable buffer */
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
fail_unless_equals_int (g_list_length (buffers), 1);
|
|
outbuffer = GST_BUFFER_CAST (buffers->data);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (outbuffer != inbuffer);
|
|
|
|
/* output buffer should be black */
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps) == TRUE);
|
|
gst_caps_unref (outcaps);
|
|
|
|
/* output buffer should have the composition meta */
|
|
comp_meta = gst_buffer_get_video_overlay_composition_meta (outbuffer);
|
|
fail_unless (comp_meta != NULL);
|
|
|
|
fail_unless (GST_BUFFER_TIMESTAMP (outbuffer) == 0);
|
|
fail_unless (GST_BUFFER_DURATION (outbuffer) == (GST_SECOND / 10));
|
|
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* cleanup */
|
|
cleanup_textoverlay (textoverlay);
|
|
gst_buffer_unref (inbuffer);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (test_video_render_with_any_features_and_no_allocation_meta)
|
|
{
|
|
GstElement *textoverlay;
|
|
GstBuffer *inbuffer, *outbuffer;
|
|
GstCaps *incaps, *outcaps;
|
|
GstVideoOverlayCompositionMeta *comp_meta;
|
|
|
|
textoverlay =
|
|
setup_textoverlay_with_templates (&video_srctemplate,
|
|
NULL, &sinktemplate_any, FALSE);
|
|
|
|
/* set static text to render */
|
|
g_object_set (textoverlay, "text", "XLX", NULL);
|
|
|
|
fail_unless (gst_element_set_state (textoverlay,
|
|
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
|
|
"could not set to playing");
|
|
|
|
incaps = create_video_caps (VIDEO_CAPS_STRING);
|
|
gst_check_setup_events_textoverlay (myvideosrcpad, textoverlay, incaps,
|
|
GST_FORMAT_TIME, "video");
|
|
inbuffer = create_black_buffer (incaps);
|
|
gst_caps_unref (incaps);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 10;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should have been dropped in favour of a new writable buffer */
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
fail_unless_equals_int (g_list_length (buffers), 1);
|
|
outbuffer = GST_BUFFER_CAST (buffers->data);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (outbuffer != inbuffer);
|
|
|
|
/* output buffer should have rendered text */
|
|
fail_if (buffer_is_all_black (outbuffer, outcaps));
|
|
gst_caps_unref (outcaps);
|
|
|
|
/* output buffer should not have the composition meta */
|
|
comp_meta = gst_buffer_get_video_overlay_composition_meta (outbuffer);
|
|
fail_unless (comp_meta == NULL);
|
|
|
|
fail_unless (GST_BUFFER_TIMESTAMP (outbuffer) == 0);
|
|
fail_unless (GST_BUFFER_DURATION (outbuffer) == (GST_SECOND / 10));
|
|
|
|
/* output caps shouldn't have the composition meta */
|
|
fail_if (_test_textoverlay_check_caps_has_feature (textoverlay, "src",
|
|
GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION));
|
|
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* cleanup */
|
|
cleanup_textoverlay (textoverlay);
|
|
gst_buffer_unref (inbuffer);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (test_video_render_static_text)
|
|
{
|
|
GstElement *textoverlay;
|
|
GstBuffer *inbuffer, *outbuffer;
|
|
GstCaps *incaps, *outcaps;
|
|
|
|
textoverlay = setup_textoverlay (TRUE);
|
|
|
|
/* set static text to render */
|
|
g_object_set (textoverlay, "text", "XLX", NULL);
|
|
|
|
fail_unless (gst_element_set_state (textoverlay,
|
|
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
|
|
"could not set to playing");
|
|
|
|
incaps = create_video_caps (VIDEO_CAPS_STRING);
|
|
gst_check_setup_events_textoverlay (myvideosrcpad, textoverlay, incaps,
|
|
GST_FORMAT_TIME, "video");
|
|
inbuffer = create_black_buffer (incaps);
|
|
gst_caps_unref (incaps);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 10;
|
|
|
|
/* take additional ref to keep it alive */
|
|
gst_buffer_ref (inbuffer);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 2);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* should have been dropped in favour of a new writable buffer */
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
fail_unless_equals_int (g_list_length (buffers), 1);
|
|
outbuffer = GST_BUFFER_CAST (buffers->data);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (outbuffer != inbuffer);
|
|
|
|
/* there should be text rendered */
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps) == FALSE);
|
|
gst_caps_unref (outcaps);
|
|
|
|
fail_unless (GST_BUFFER_TIMESTAMP (outbuffer) == 0);
|
|
fail_unless (GST_BUFFER_DURATION (outbuffer) == (GST_SECOND / 10));
|
|
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* cleanup */
|
|
cleanup_textoverlay (textoverlay);
|
|
gst_buffer_unref (inbuffer);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static gpointer
|
|
test_video_waits_for_text_send_text_newsegment_thread (gpointer data)
|
|
{
|
|
GstSegment segment;
|
|
|
|
g_usleep (1 * G_USEC_PER_SEC);
|
|
|
|
/* send an update newsegment; the video buffer should now be pushed through
|
|
* even though there is no text buffer queued at the moment */
|
|
GST_INFO ("Sending newsegment update on text pad");
|
|
gst_segment_init (&segment, GST_FORMAT_TIME);
|
|
segment.base = 35 * GST_SECOND;
|
|
segment.start = 35 * GST_SECOND;
|
|
segment.time = 35 * GST_SECOND;
|
|
gst_pad_push_event (mytextsrcpad, gst_event_new_segment (&segment));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static gpointer
|
|
test_video_waits_for_text_shutdown_element (gpointer data)
|
|
{
|
|
g_usleep (1 * G_USEC_PER_SEC);
|
|
|
|
GST_INFO ("Trying to shut down textoverlay element ...");
|
|
/* set to NULL state to make sure we can shut it down while it's
|
|
* blocking in the video chain function waiting for a text buffer */
|
|
gst_element_set_state (GST_ELEMENT (data), GST_STATE_NULL);
|
|
GST_INFO ("Done.");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
GST_START_TEST (test_video_waits_for_text)
|
|
{
|
|
GstElement *textoverlay;
|
|
GstBuffer *inbuffer, *outbuffer, *tbuf;
|
|
GstCaps *caps, *incaps, *outcaps;
|
|
GThread *thread;
|
|
|
|
textoverlay = setup_textoverlay (FALSE);
|
|
|
|
fail_unless (gst_element_set_state (textoverlay,
|
|
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
|
|
"could not set to playing");
|
|
|
|
caps = gst_caps_new_simple ("text/x-raw", "format", G_TYPE_STRING, "utf8",
|
|
NULL);
|
|
gst_check_setup_events_textoverlay (mytextsrcpad, textoverlay, caps,
|
|
GST_FORMAT_TIME, "text");
|
|
gst_caps_unref (caps);
|
|
|
|
tbuf = create_text_buffer ("XLX", 1 * GST_SECOND, 5 * GST_SECOND);
|
|
gst_buffer_ref (tbuf);
|
|
ASSERT_BUFFER_REFCOUNT (tbuf, "tbuf", 2);
|
|
|
|
GST_LOG ("pushing text buffer");
|
|
fail_unless (gst_pad_push (mytextsrcpad, tbuf) == GST_FLOW_OK);
|
|
|
|
/* it should be stuck in textoverlay until it gets a text buffer or a
|
|
* newsegment event that indicates it's not needed any longer */
|
|
fail_unless_equals_int (g_list_length (buffers), 0);
|
|
|
|
incaps = create_video_caps (VIDEO_CAPS_STRING);
|
|
gst_check_setup_events_textoverlay (myvideosrcpad, textoverlay, incaps,
|
|
GST_FORMAT_TIME, "video");
|
|
inbuffer = create_black_buffer (incaps);
|
|
gst_caps_unref (incaps);
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 0;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 2;
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
GST_LOG ("pushing video buffer 1");
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* video buffer should have gone through untainted, since the text is later */
|
|
fail_unless_equals_int (g_list_length (buffers), 1);
|
|
|
|
/* text should still be stuck in textoverlay */
|
|
ASSERT_MINI_OBJECT_REFCOUNT (gst_buffer_peek_memory (tbuf, 0), "tbuf-mem", 2);
|
|
|
|
/* there should be no text rendered */
|
|
outbuffer = GST_BUFFER_CAST (buffers->data);
|
|
ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps));
|
|
gst_caps_unref (outcaps);
|
|
|
|
/* now, another video buffer */
|
|
inbuffer = create_black_buffer (incaps);
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = GST_SECOND;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 2;
|
|
ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
GST_LOG ("pushing video buffer 2");
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* video buffer should have gone right away, with text rendered on it */
|
|
fail_unless_equals_int (g_list_length (buffers), 2);
|
|
|
|
/* text should still be stuck in textoverlay */
|
|
ASSERT_MINI_OBJECT_REFCOUNT (gst_buffer_peek_memory (tbuf, 0), "tbuf-mem", 2);
|
|
|
|
/* there should be text rendered */
|
|
outbuffer = GST_BUFFER_CAST (buffers->next->data);
|
|
ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps) == FALSE);
|
|
gst_caps_unref (outcaps);
|
|
|
|
/* a third video buffer */
|
|
inbuffer = create_black_buffer (incaps);
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 30 * GST_SECOND;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND / 2;
|
|
|
|
/* video buffer #3: should not go through, it should discard the current
|
|
* text buffer as too old and then wait for the next text buffer (or a
|
|
* newsegment event to arrive); we spawn a background thread to send such
|
|
* a newsegment event after a second or so so we get back control */
|
|
thread =
|
|
g_thread_try_new ("gst-check",
|
|
test_video_waits_for_text_send_text_newsegment_thread, NULL, NULL);
|
|
fail_unless (thread != NULL);
|
|
g_thread_unref (thread);
|
|
|
|
GST_LOG ("pushing video buffer 3");
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_OK);
|
|
|
|
/* but the text should no longer be stuck in textoverlay */
|
|
ASSERT_MINI_OBJECT_REFCOUNT (gst_buffer_peek_memory (tbuf, 0), "tbuf-mem", 1);
|
|
|
|
/* video buffer should have gone through after newsegment event */
|
|
fail_unless_equals_int (g_list_length (buffers), 3);
|
|
|
|
/* ... and there should not be any text rendered on it */
|
|
outbuffer = GST_BUFFER_CAST (buffers->next->next->data);
|
|
ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
fail_unless (buffer_is_all_black (outbuffer, outcaps));
|
|
gst_caps_unref (outcaps);
|
|
|
|
/* a fourth video buffer */
|
|
inbuffer = create_black_buffer (incaps);
|
|
GST_BUFFER_TIMESTAMP (inbuffer) = 35 * GST_SECOND;
|
|
GST_BUFFER_DURATION (inbuffer) = GST_SECOND;
|
|
|
|
/* video buffer #4: should not go through, it should wait for the next
|
|
* text buffer (or a newsegment event) to arrive; we spawn a background
|
|
* thread to shut down the element while it's waiting to make sure that
|
|
* works ok */
|
|
thread = g_thread_try_new ("gst-check",
|
|
test_video_waits_for_text_shutdown_element, textoverlay, NULL);
|
|
fail_unless (thread != NULL);
|
|
g_thread_unref (thread);
|
|
|
|
GST_LOG ("pushing video buffer 4");
|
|
fail_unless (gst_pad_push (myvideosrcpad, inbuffer) == GST_FLOW_FLUSHING);
|
|
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
|
|
/* cleanup */
|
|
cleanup_textoverlay (textoverlay);
|
|
|
|
/* give up our ref, textoverlay should've cleared its queued buffer by now */
|
|
ASSERT_BUFFER_REFCOUNT (tbuf, "tbuf", 1);
|
|
gst_buffer_unref (tbuf);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static gpointer
|
|
test_render_continuity_push_video_buffers_thread (gpointer data)
|
|
{
|
|
/* push video buffers at 1fps */
|
|
guint frame_count = 0;
|
|
GstCaps *vcaps;
|
|
|
|
vcaps = create_video_caps (VIDEO_CAPS_STRING);
|
|
gst_check_setup_events_textoverlay (myvideosrcpad, data, vcaps,
|
|
GST_FORMAT_TIME, "video");
|
|
|
|
do {
|
|
GstBuffer *vbuf;
|
|
|
|
vbuf = create_black_buffer (vcaps);
|
|
ASSERT_BUFFER_REFCOUNT (vbuf, "vbuf", 1);
|
|
|
|
GST_BUFFER_TIMESTAMP (vbuf) = frame_count * GST_SECOND;
|
|
GST_BUFFER_DURATION (vbuf) = GST_SECOND;
|
|
|
|
/* pushing gives away one of the two references we have ... */
|
|
GST_LOG ("pushing video buffer %u @ %" GST_TIME_FORMAT, frame_count,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (vbuf)));
|
|
fail_unless (gst_pad_push (myvideosrcpad, vbuf) == GST_FLOW_OK);
|
|
|
|
++frame_count;
|
|
} while (frame_count < 15);
|
|
|
|
gst_caps_unref (vcaps);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
GST_START_TEST (test_render_continuity)
|
|
{
|
|
GThread *thread;
|
|
GstElement *textoverlay;
|
|
GstBuffer *tbuf;
|
|
GstCaps *caps, *outcaps;
|
|
|
|
textoverlay = setup_textoverlay (FALSE);
|
|
|
|
fail_unless (gst_element_set_state (textoverlay,
|
|
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
|
|
"could not set to playing");
|
|
|
|
thread = g_thread_try_new ("gst-check",
|
|
test_render_continuity_push_video_buffers_thread, textoverlay, NULL);
|
|
fail_unless (thread != NULL);
|
|
g_thread_unref (thread);
|
|
|
|
caps = gst_caps_new_simple ("text/x-raw", "format", G_TYPE_STRING, "utf8",
|
|
NULL);
|
|
gst_check_setup_events_textoverlay (mytextsrcpad, textoverlay, caps,
|
|
GST_FORMAT_TIME, "text");
|
|
gst_caps_unref (caps);
|
|
|
|
tbuf = create_text_buffer ("XLX", 2 * GST_SECOND, GST_SECOND);
|
|
GST_LOG ("pushing text buffer @ %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (tbuf)));
|
|
fail_unless (gst_pad_push (mytextsrcpad, tbuf) == GST_FLOW_OK);
|
|
|
|
tbuf = create_text_buffer ("XLX", 3 * GST_SECOND, 2 * GST_SECOND);
|
|
GST_LOG ("pushing text buffer @ %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (tbuf)));
|
|
fail_unless (gst_pad_push (mytextsrcpad, tbuf) == GST_FLOW_OK);
|
|
|
|
tbuf = create_text_buffer ("XLX", 7 * GST_SECOND, GST_SECOND);
|
|
GST_LOG ("pushing text buffer @ %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (tbuf)));
|
|
fail_unless (gst_pad_push (mytextsrcpad, tbuf) == GST_FLOW_OK);
|
|
|
|
tbuf = create_text_buffer ("XLX", 8 * GST_SECOND, GST_SECOND);
|
|
GST_LOG ("pushing text buffer @ %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (tbuf)));
|
|
fail_unless (gst_pad_push (mytextsrcpad, tbuf) == GST_FLOW_OK);
|
|
|
|
tbuf = create_text_buffer ("XLX", 9 * GST_SECOND, GST_SECOND);
|
|
GST_LOG ("pushing text buffer @ %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (tbuf)));
|
|
fail_unless (gst_pad_push (mytextsrcpad, tbuf) == GST_FLOW_OK);
|
|
|
|
tbuf = create_text_buffer ("XLX", 10 * GST_SECOND, 30 * GST_SECOND);
|
|
GST_LOG ("pushing text buffer @ %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (tbuf)));
|
|
fail_unless (gst_pad_push (mytextsrcpad, tbuf) == GST_FLOW_OK);
|
|
|
|
GST_LOG ("give the other thread some time to push through the remaining"
|
|
"video buffers");
|
|
g_usleep (G_USEC_PER_SEC);
|
|
GST_LOG ("done");
|
|
|
|
/* we should have 15 buffers each with one second length now */
|
|
fail_unless_equals_int (g_list_length (buffers), 15);
|
|
|
|
outcaps = gst_pad_get_current_caps (mysinkpad);
|
|
|
|
/* buffers 0 + 1 should be black */
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers, 0)),
|
|
outcaps));
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers, 1)),
|
|
outcaps));
|
|
|
|
/* buffers 2 - 4 should have text */
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
2)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
3)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
4)), outcaps) == FALSE);
|
|
|
|
/* buffers 5 + 6 should be black */
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers, 5)),
|
|
outcaps));
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers, 6)),
|
|
outcaps));
|
|
|
|
/* buffers 7 - last should have text */
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
7)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
8)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
9)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
10)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
11)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
12)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
13)), outcaps) == FALSE);
|
|
fail_unless (buffer_is_all_black (GST_BUFFER (g_list_nth_data (buffers,
|
|
14)), outcaps) == FALSE);
|
|
gst_caps_unref (outcaps);
|
|
|
|
/* and clean up */
|
|
g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (buffers);
|
|
buffers = NULL;
|
|
|
|
/* cleanup */
|
|
cleanup_textoverlay (textoverlay);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static Suite *
|
|
textoverlay_suite (void)
|
|
{
|
|
Suite *s = suite_create ("textoverlay");
|
|
TCase *tc_chain = tcase_create ("general");
|
|
|
|
suite_add_tcase (s, tc_chain);
|
|
|
|
tcase_add_test (tc_chain, test_video_passthrough);
|
|
tcase_add_test (tc_chain, test_video_passthrough_with_feature);
|
|
tcase_add_test (tc_chain,
|
|
test_video_passthrough_with_feature_and_unsupported_caps);
|
|
tcase_add_test (tc_chain,
|
|
test_video_render_with_any_features_and_no_allocation_meta);
|
|
tcase_add_test (tc_chain, test_video_render_static_text);
|
|
tcase_add_test (tc_chain, test_render_continuity);
|
|
tcase_add_test (tc_chain, test_video_waits_for_text);
|
|
|
|
return s;
|
|
}
|
|
|
|
GST_CHECK_MAIN (textoverlay);
|