mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-08 13:18:52 +00:00
725 lines
22 KiB
C
725 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_static_pad_template (gstelement_class,
|
|
&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;
|
|
}
|
|
g_free (src->http_method_name);
|
|
src->http_method_name = NULL;
|
|
g_free (src->user_agent);
|
|
src->user_agent = 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 (TEST_HTTP_SRC_REQUEST_HEADERS_NAME);
|
|
}
|
|
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, TEST_HTTP_SRC_REQUEST_HEADERS_NAME,
|
|
GST_TYPE_STRUCTURE, src->input.request_headers, NULL);
|
|
if (!src->input.response_headers) {
|
|
src->input.response_headers =
|
|
gst_structure_new_empty (TEST_HTTP_SRC_RESPONSE_HEADERS_NAME);
|
|
}
|
|
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, TEST_HTTP_SRC_RESPONSE_HEADERS_NAME,
|
|
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:{
|
|
guint i;
|
|
|
|
g_free (src->http_method_name);
|
|
src->http_method_name = g_value_dup_string (value);
|
|
src->http_method = METHOD_INVALID;
|
|
for (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;
|
|
}
|