mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 13:48:55 +00:00
Following the Don't Repeat Yourself principle, define macros for the structures that contain the request and response headers, so that the name is not repeated in multiple places in multiple files. https://bugzilla.gnome.org/show_bug.cgi?id=762144
722 lines
22 KiB
C
722 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:
|
|
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;
|
|
}
|