gstreamer/tests/check/elements/test_http_src.c
Alex Ashley ae3ed25025 dashdemux: tests: Refactor into adaptive_engine components
To allow code from dash_demux.c to be used by other elements
that are based upon GstAdaptiveDemux, the code has been
refactored into four new files:

	adaptive_demux_engine.[ch]
	adaptive_demux_common.[ch]

The code in adaptive_demux_engine.c provides a generic
test engine for elements based upon GstAdaptiveDemux.

The code in adaptive_demux_common.c provides a set
of utility functions that are common between the tests
for hlsdemux and dashdemux.

As part of the refactoring, variables in structures were
renamed from using camelCase to underscore_case to match other
GStreamer source code.

The fake_http_src was renamed test_http_src and changed to use
callbacks to provide input data and error conditions. Rather than
using an array of input data that tries to encode all the
possible use cases for the GstTestHTTPSrc element, use a struct of
callbacks.

Users of this element are obliged to implement at least the src_start
callback, which provides a way to link from a URI to the settings
for that URI.
2015-12-22 11:15:32 -03:00

716 lines
22 KiB
C

/* HTTP source element for use in tests
*
* Copyright (c) <2015> YouView TV Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <gst/check/gstcheck.h>
#include <gst/base/gstbasesrc.h>
#include "test_http_src.h"
#ifndef GST_PACKAGE_NAME
#define GST_PACKAGE_NAME "gst-plugins-bad"
#endif
#ifndef GST_PACKAGE_ORIGIN
#define GST_PACKAGE_ORIGIN "https://developer.gnome.org/gstreamer/"
#endif
#define GST_TEST_HTTP_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_TEST_HTTP_SRC, GstTestHTTPSrc))
#define GST_TEST_HTTP_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_TEST_HTTP_SRC, GstTestHTTPSrcClass))
#define GST_IS_TEST_HTTP_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_TEST_HTTP_SRC))
#define GST_IS_TEST_HTTP_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_TEST_HTTP_SRC))
#define GST_TEST_HTTP_SRC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_TEST_HTTP_SRC, GstTestHTTPSrcClass))
#define DEFAULT_USER_AGENT "GStreamer testhttpsrc "
#define DEFAULT_COMPRESS FALSE
#define DEFAULT_HTTP_METHOD NULL
#define DEFAULT_KEEP_ALIVE FALSE
enum
{
PROP_0,
PROP_USER_AGENT,
PROP_EXTRA_HEADERS,
PROP_COMPRESS,
PROP_KEEP_ALIVE,
PROP_METHOD,
PROP_LAST
};
typedef enum
{
METHOD_INVALID,
METHOD_GET,
METHOD_POST,
METHOD_HEAD,
METHOD_OPTIONS
} HttpMethod;
typedef struct _GstTestHTTPSrcMethodName
{
const gchar *name;
HttpMethod method;
} GstTestHTTPSrcMethodName;
static const GstTestHTTPSrcMethodName gst_test_http_src_methods[] = {
{"GET", METHOD_GET},
{"POST", METHOD_POST},
{"HEAD", METHOD_HEAD},
{"OPTIONS", METHOD_OPTIONS},
{NULL, METHOD_INVALID}
};
typedef struct _GstTestHTTPSrc
{
GstBaseSrc parent;
GMutex mutex;
GstTestHTTPSrcInput input;
gchar *uri; /* the uri for which data is being requested */
gboolean compress;
gboolean keep_alive;
gchar *http_method_name;
HttpMethod http_method;
GstStructure *extra_headers;
gchar *user_agent;
guint64 position;
/* index immediately after the last byte from the segment to be retrieved */
guint64 segment_end;
GstEvent *http_headers_event;
gboolean duration_changed;
} GstTestHTTPSrc;
typedef struct _GstTestHTTPSrcClass
{
GstBaseSrcClass parent_class;
} GstTestHTTPSrcClass;
typedef struct _PluginInitContext
{
const gchar *name;
guint rank;
GType type;
} PluginInitContext;
static const GstTestHTTPSrcCallbacks *gst_test_http_src_callbacks = NULL;
static gpointer gst_test_http_src_callback_user_data = NULL;
static guint gst_test_http_src_blocksize = 0;
static GstStaticPadTemplate gst_dashdemux_test_source_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
static void gst_test_http_src_uri_handler_init (gpointer g_iface,
gpointer iface_data);
static void gst_test_http_src_finalize (GObject * object);
static gboolean gst_test_http_src_is_seekable (GstBaseSrc * basesrc);
static gboolean gst_test_http_src_do_seek (GstBaseSrc * basesrc,
GstSegment * segment);
static gboolean gst_test_http_src_start (GstBaseSrc * basesrc);
static gboolean gst_test_http_src_stop (GstBaseSrc * basesrc);
static gboolean gst_test_http_src_get_size (GstBaseSrc * basesrc,
guint64 * size);
static GstFlowReturn gst_test_http_src_create (GstBaseSrc * basesrc,
guint64 offset, guint length, GstBuffer ** ret);
static void gst_test_http_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_test_http_src_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
#define _do_init \
G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, gst_test_http_src_uri_handler_init);
#define gst_test_http_src_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstTestHTTPSrc, gst_test_http_src,
GST_TYPE_BASE_SRC, _do_init);
static void
gst_test_http_src_class_init (GstTestHTTPSrcClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseSrcClass *gstbasesrc_class;
gobject_class = G_OBJECT_CLASS (klass);
gstelement_class = GST_ELEMENT_CLASS (klass);
gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
gobject_class->set_property = gst_test_http_src_set_property;
gobject_class->get_property = gst_test_http_src_get_property;
gobject_class->finalize = gst_test_http_src_finalize;
g_object_class_install_property (gobject_class, PROP_COMPRESS,
g_param_spec_boolean ("compress", "Compress",
"Allow compressed content encodings",
DEFAULT_COMPRESS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_EXTRA_HEADERS,
g_param_spec_boxed ("extra-headers", "Extra Headers",
"Extra headers to append to the HTTP request",
GST_TYPE_STRUCTURE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_KEEP_ALIVE,
g_param_spec_boolean ("keep-alive", "keep-alive",
"Use HTTP persistent connections", DEFAULT_KEEP_ALIVE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_METHOD,
g_param_spec_string ("method", "HTTP method",
"The HTTP method to use (GET, HEAD, OPTIONS, etc)",
DEFAULT_HTTP_METHOD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_USER_AGENT,
g_param_spec_string ("user-agent", "User-Agent",
"Value of the User-Agent HTTP request header field",
DEFAULT_USER_AGENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
gst_element_class_set_metadata (gstelement_class,
"Test HTTP source element for unit tests",
"Source/Network",
"Use in unit tests", "Alex Ashley <alex.ashley@youview.com>");
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_dashdemux_test_source_template));
gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_test_http_src_start);
gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_test_http_src_stop);
gstbasesrc_class->is_seekable =
GST_DEBUG_FUNCPTR (gst_test_http_src_is_seekable);
gstbasesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_test_http_src_do_seek);
gstbasesrc_class->get_size = GST_DEBUG_FUNCPTR (gst_test_http_src_get_size);
gstbasesrc_class->create = GST_DEBUG_FUNCPTR (gst_test_http_src_create);
}
static void
gst_test_http_src_init (GstTestHTTPSrc * src)
{
g_mutex_init (&src->mutex);
src->uri = NULL;
memset (&src->input, 0, sizeof (src->input));
src->compress = FALSE;
src->keep_alive = FALSE;
src->http_method_name = NULL;
src->http_method = METHOD_GET;
src->user_agent = NULL;
src->position = 0;
src->segment_end = 0;
src->http_headers_event = NULL;
src->duration_changed = FALSE;
if (gst_test_http_src_blocksize)
gst_base_src_set_blocksize (GST_BASE_SRC (src),
gst_test_http_src_blocksize);
}
static void
gst_test_http_src_reset_input (GstTestHTTPSrc * src)
{
src->input.context = NULL;
src->input.size = 0;
src->input.status_code = 0;
if (src->input.request_headers) {
gst_structure_free (src->input.request_headers);
src->input.request_headers = NULL;
}
if (src->input.response_headers) {
gst_structure_free (src->input.response_headers);
src->input.response_headers = NULL;
}
if (src->http_headers_event) {
gst_event_unref (src->http_headers_event);
src->http_headers_event = NULL;
}
if (src->extra_headers) {
gst_structure_free (src->extra_headers);
src->extra_headers = NULL;
}
src->duration_changed = FALSE;
}
static void
gst_test_http_src_finalize (GObject * object)
{
GstTestHTTPSrc *src;
src = GST_TEST_HTTP_SRC (object);
g_free (src->uri);
gst_test_http_src_reset_input (src);
g_mutex_clear (&src->mutex);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gboolean
gst_test_http_src_start (GstBaseSrc * basesrc)
{
GstTestHTTPSrc *src;
GstStructure *http_headers;
src = GST_TEST_HTTP_SRC (basesrc);
g_mutex_lock (&src->mutex);
gst_test_http_src_reset_input (src);
if (!src->uri) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (("No URL set.")),
("Missing location property"));
g_mutex_unlock (&src->mutex);
return FALSE;
}
if (!gst_test_http_src_callbacks) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
(("Callbacks not registered.")), ("Callbacks not registered"));
g_mutex_unlock (&src->mutex);
return FALSE;
}
if (!gst_test_http_src_callbacks->src_start) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
(("src_start callback not defined.")),
("src_start callback not registered"));
g_mutex_unlock (&src->mutex);
return FALSE;
}
if (!gst_test_http_src_callbacks->src_start (src, src->uri, &src->input,
gst_test_http_src_callback_user_data)) {
if (src->input.status_code == 0) {
src->input.status_code = 404;
}
} else {
if (src->input.status_code == 0) {
src->input.status_code = 200;
}
src->position = 0;
src->segment_end = src->input.size;
gst_base_src_set_dynamic_size (basesrc, FALSE);
basesrc->segment.duration = src->input.size;
src->duration_changed = TRUE;
}
http_headers = gst_structure_new_empty ("http-headers");
gst_structure_set (http_headers, "uri", G_TYPE_STRING, src->uri, NULL);
if (!src->input.request_headers) {
src->input.request_headers = gst_structure_new_empty ("request-headers");
}
if (!gst_structure_has_field_typed (src->input.request_headers,
"User-Agent", G_TYPE_STRING)) {
gst_structure_set (src->input.request_headers,
"User-Agent", G_TYPE_STRING,
src->user_agent ? src->user_agent : DEFAULT_USER_AGENT, NULL);
}
if (!gst_structure_has_field_typed (src->input.request_headers,
"Connection", G_TYPE_STRING)) {
gst_structure_set (src->input.request_headers,
"Connection", G_TYPE_STRING,
src->keep_alive ? "Keep-Alive" : "Close", NULL);
}
if (src->compress
&& !gst_structure_has_field_typed (src->input.request_headers,
"Accept-Encoding", G_TYPE_STRING)) {
gst_structure_set (src->input.request_headers, "Accept-Encoding",
G_TYPE_STRING, "compress, gzip", NULL);
}
gst_structure_set (http_headers, "request-headers", GST_TYPE_STRUCTURE,
src->input.request_headers, NULL);
if (!src->input.response_headers) {
src->input.response_headers = gst_structure_new_empty ("response-headers");
}
if (!gst_structure_has_field_typed (src->input.response_headers,
"Connection", G_TYPE_STRING)) {
gst_structure_set (src->input.response_headers,
"Connection", G_TYPE_STRING,
src->keep_alive ? "keep-alive" : "close", NULL);
}
if (!gst_structure_has_field_typed (src->input.response_headers,
"Date", G_TYPE_STRING)) {
GDateTime *now;
gchar *date_str;
now = g_date_time_new_now_local ();
fail_unless (now != NULL);
date_str = g_date_time_format (now, "%a, %e %b %Y %T %Z");
fail_unless (date_str != NULL);
gst_structure_set (src->input.response_headers,
"Date", G_TYPE_STRING, date_str, NULL);
g_free (date_str);
g_date_time_unref (now);
}
gst_structure_set (http_headers, "response-headers", GST_TYPE_STRUCTURE,
src->input.response_headers, NULL);
if (src->http_headers_event) {
gst_event_unref (src->http_headers_event);
}
src->http_headers_event =
gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_STICKY, http_headers);
g_mutex_unlock (&src->mutex);
return TRUE;
}
static gboolean
gst_test_http_src_stop (GstBaseSrc * basesrc)
{
GstTestHTTPSrc *src;
src = GST_TEST_HTTP_SRC (basesrc);
g_mutex_lock (&src->mutex);
src->position = 0;
gst_test_http_src_reset_input (src);
g_mutex_unlock (&src->mutex);
return TRUE;
}
static gboolean
gst_test_http_src_is_seekable (GstBaseSrc * basesrc)
{
GstTestHTTPSrc *src;
gboolean ret;
src = GST_TEST_HTTP_SRC (basesrc);
g_mutex_lock (&src->mutex);
/* if size is set, we can seek */
ret = src->input.size > 0;
g_mutex_unlock (&src->mutex);
return ret;
}
static gboolean
gst_test_http_src_do_seek (GstBaseSrc * basesrc, GstSegment * segment)
{
GstTestHTTPSrc *src = GST_TEST_HTTP_SRC (basesrc);
GST_DEBUG ("gst_test_http_src_do_seek start = %" G_GUINT64_FORMAT,
segment->start);
/*
According to RFC7233, the range is inclusive:
The first-byte-pos value in a byte-range-spec gives the byte-offset
of the first byte in a range. The last-byte-pos value gives the
byte-offset of the last byte in the range; that is, the byte
positions specified are inclusive. Byte offsets start at zero.
*/
g_mutex_lock (&src->mutex);
if (!src->uri) {
GST_DEBUG ("attempt to seek before URI set");
g_mutex_unlock (&src->mutex);
return FALSE;
}
if (src->input.status_code >= 200 && src->input.status_code < 300) {
if (segment->start >= src->input.size) {
GST_DEBUG ("attempt to seek to %" G_GUINT64_FORMAT " but size is %"
G_GUINT64_FORMAT, segment->start, src->input.size);
g_mutex_unlock (&src->mutex);
return FALSE;
}
if (segment->stop != -1 && segment->stop > src->input.size) {
g_mutex_unlock (&src->mutex);
return FALSE;
}
} else {
GST_DEBUG ("Attempt to seek on a URL that will generate HTTP error %u",
src->input.status_code);
}
src->position = segment->start;
if (segment->stop != -1) {
src->segment_end = segment->stop;
} else {
src->segment_end = src->input.size;
}
g_mutex_unlock (&src->mutex);
return TRUE;
}
static gboolean
gst_test_http_src_get_size (GstBaseSrc * basesrc, guint64 * size)
{
GstTestHTTPSrc *src;
src = GST_TEST_HTTP_SRC (basesrc);
g_mutex_lock (&src->mutex);
/* if it was started, size is set */
if (src->uri && src->input.status_code >= 200 && src->input.status_code < 300) {
*size = src->input.size;
g_mutex_unlock (&src->mutex);
return TRUE;
}
/* cannot get the size if it wasn't started */
g_mutex_unlock (&src->mutex);
return FALSE;
}
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;
}
static void
gst_test_http_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstTestHTTPSrc *src = GST_TEST_HTTP_SRC (object);
switch (prop_id) {
case PROP_USER_AGENT:
g_free (src->user_agent);
src->user_agent = g_value_dup_string (value);
break;
case PROP_EXTRA_HEADERS:{
const GstStructure *s = gst_value_get_structure (value);
if (src->extra_headers)
gst_structure_free (src->extra_headers);
src->extra_headers = s ? gst_structure_copy (s) : NULL;
break;
}
case PROP_COMPRESS:
src->compress = g_value_get_boolean (value);
GST_DEBUG ("Set compress=%s", src->compress ? "TRUE" : "FALSE");
break;
case PROP_KEEP_ALIVE:
src->keep_alive = g_value_get_boolean (value);
break;
case PROP_METHOD:
g_free (src->http_method_name);
src->http_method_name = g_value_dup_string (value);
src->http_method = METHOD_INVALID;
for (guint i = 0; gst_test_http_src_methods[i].name; ++i) {
if (strcmp (gst_test_http_src_methods[i].name,
src->http_method_name) == 0) {
src->http_method = gst_test_http_src_methods[i].method;
break;
}
}
/* we don't cause an error for an invalid method at this point,
as GstSoupHTTPSrc does not use the http_method_name string until
trying to open a connection.
*/
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_test_http_src_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstTestHTTPSrc *src = GST_TEST_HTTP_SRC (object);
switch (prop_id) {
case PROP_USER_AGENT:
g_value_set_string (value, src->user_agent);
break;
case PROP_EXTRA_HEADERS:
gst_value_set_structure (value, src->extra_headers);
break;
case PROP_COMPRESS:
g_value_set_boolean (value, src->compress);
break;
case PROP_KEEP_ALIVE:
g_value_set_boolean (value, src->keep_alive);
break;
case PROP_METHOD:
g_value_set_string (value, src->http_method_name);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_test_http_src_set_location (GstTestHTTPSrc * src,
const gchar * uri, GError ** error)
{
g_mutex_lock (&src->mutex);
g_free (src->uri);
src->uri = g_strdup (uri);
g_mutex_unlock (&src->mutex);
return TRUE;
}
static GstURIType
gst_test_http_src_uri_get_type (GType type)
{
return GST_URI_SRC;
}
static const gchar *const *
gst_test_http_src_uri_get_protocols (GType type)
{
static const gchar *protocols[] = { "http", NULL };
return protocols;
}
static gchar *
gst_test_http_src_uri_get_uri (GstURIHandler * handler)
{
GstTestHTTPSrc *src = GST_TEST_HTTP_SRC (handler);
gchar *ret;
g_mutex_lock (&src->mutex);
ret = g_strdup (src->uri);
g_mutex_unlock (&src->mutex);
return ret;
}
static gboolean
gst_test_http_src_uri_set_uri (GstURIHandler * handler, const gchar * uri,
GError ** err)
{
GstTestHTTPSrc *src = GST_TEST_HTTP_SRC (handler);
return gst_test_http_src_set_location (src, uri, err);
}
static void
gst_test_http_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
{
GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
iface->get_type = gst_test_http_src_uri_get_type;
iface->get_protocols = gst_test_http_src_uri_get_protocols;
iface->get_uri = gst_test_http_src_uri_get_uri;
iface->set_uri = gst_test_http_src_uri_set_uri;
}
static gboolean
gst_test_http_src_plugin_init_func (GstPlugin * plugin, gpointer user_data)
{
PluginInitContext *context = (PluginInitContext *) user_data;
gboolean ret;
ret =
gst_element_register (plugin, context->name, context->rank,
context->type);
return ret;
}
gboolean
gst_test_http_src_register_plugin (GstRegistry * registry, const gchar * name)
{
gboolean ret;
PluginInitContext context;
context.name = name;
context.rank = GST_RANK_PRIMARY + 1;
context.type = GST_TYPE_TEST_HTTP_SRC;
ret = gst_plugin_register_static_full (GST_VERSION_MAJOR, /* version */
GST_VERSION_MINOR, /* version */
name, /* name */
"Replaces a souphttpsrc plugin and returns predefined data.", /* description */
gst_test_http_src_plugin_init_func, /* init function */
"0.0.0", /* version string */
GST_LICENSE_UNKNOWN, /* license */
__FILE__, /* source */
GST_PACKAGE_NAME, /* package */
GST_PACKAGE_ORIGIN, /* origin */
&context /* user_data */
);
return ret;
}
void
gst_test_http_src_install_callbacks (const GstTestHTTPSrcCallbacks *
callbacks, gpointer user_data)
{
gst_test_http_src_callbacks = callbacks;
gst_test_http_src_callback_user_data = user_data;
}
void
gst_test_http_src_set_default_blocksize (guint blocksize)
{
gst_test_http_src_blocksize = blocksize;
}