mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-19 00:01:23 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/plugins/elements/gstfilesrc.c
Wim Taymans c2f41a8906 Next big merge. 
Original commit message from CVS:
Next big merge.
Added GstBus for mainloop integration.
Added GstMessage for sending notifications on the bus.
Added GstTask as an abstraction for pipeline entry points.
Removed GstThread.
Removed Schedulers.
Simplified GstQueue for multithreaded core.
Made _link threadsafe, removed old capsnego.
Added STREAM_LOCK and PREROLL_LOCK in GstPad.
Added pad blocking functions.
Reworked scheduling functions in GstPad to prepare for
scheduling updates soon.
Moved events out of data stream.
Simplified GstEvent types.
Added return values to push/pull.
Removed clocking from GstElement.
Added prototypes for state change function for next merge.
Removed iterate from bins and state change management.
Fixed some elements, disabled others for now.
Fixed -inspect and -launch.
Added check for GstBus.
2005-03-21 17:34:02 +00:00

1276 lines
36 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstfilesrc.c:
*
* 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., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <gst/gst.h>
#include "gstfilesrc.h"
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_MMAP
#include <sys/mman.h>
#endif
#include <errno.h>
#include <string.h>
#include "../gst-i18n-lib.h"
static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
/* FIXME we should be using glib for this */
#ifndef S_ISREG
#define S_ISREG(mode) ((mode)&_S_IFREG)
#endif
#ifndef S_ISDIR
#define S_ISDIR(mode) ((mode)&_S_IFDIR)
#endif
#ifndef S_ISSOCK
#define S_ISSOCK(x) (0)
#endif
#ifndef O_BINARY
#define O_BINARY (0)
#endif
/**********************************************************************
* GStreamer Default File Source
* Theory of Operation
*
* This source uses mmap(2) to efficiently load data from a file.
* To do this without seriously polluting the applications' memory
* space, it must do so in smaller chunks, say 1-4MB at a time.
* Buffers are then subdivided from these mmap'd chunks, to directly
* make use of the mmap.
*
* To handle refcounting so that the mmap can be freed at the appropriate
* time, a buffer will be created for each mmap'd region, and all new
* buffers will be sub-buffers of this top-level buffer. As they are
* freed, the refcount goes down on the mmap'd buffer and its free()
* function is called, which will call munmap(2) on itself.
*
* If a buffer happens to cross the boundaries of an mmap'd region, we
* have to decide whether it's more efficient to copy the data into a
* new buffer, or mmap() just that buffer. There will have to be a
* breakpoint size to determine which will be done. The mmap() size
* has a lot to do with this as well, because you end up in double-
* jeopardy: the larger the outgoing buffer, the more data to copy when
* it overlaps, *and* the more frequently you'll have buffers that *do*
* overlap.
*
* Seeking is another tricky aspect to do efficiently. The initial
* implementation of this source won't make use of these features, however.
* The issue is that if an application seeks backwards in a file, *and*
* that region of the file is covered by an mmap that hasn't been fully
* deallocated, we really should re-use it. But keeping track of these
* regions is tricky because we have to lock the structure that holds
* them. We need to settle on a locking primitive (GMutex seems to be
* a really good option...), then we can do that.
*/
GST_DEBUG_CATEGORY_STATIC (gst_filesrc_debug);
#define GST_CAT_DEFAULT gst_filesrc_debug
GstElementDetails gst_filesrc_details = GST_ELEMENT_DETAILS ("File Source",
"Source/File",
"Read from arbitrary point in a file",
"Erik Walthinsen <omega@cse.ogi.edu>");
#define DEFAULT_BLOCKSIZE 4*1024
#define DEFAULT_MMAPSIZE 4*1024*1024
/* FileSrc signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
ARG_0,
ARG_LOCATION,
ARG_FD,
ARG_BLOCKSIZE,
ARG_MMAPSIZE,
ARG_TOUCH
};
static const GstEventMask *
gst_filesrc_get_event_mask (GstPad * pad)
{
static const GstEventMask masks[] = {
{GST_EVENT_SEEK, GST_SEEK_METHOD_CUR |
GST_SEEK_METHOD_SET | GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH},
{GST_EVENT_FLUSH, 0},
{GST_EVENT_SIZE, 0},
{0, 0}
};
return masks;
}
static const GstQueryType *
gst_filesrc_get_query_types (GstPad * pad)
{
static const GstQueryType types[] = {
GST_QUERY_TOTAL,
GST_QUERY_POSITION,
0
};
return types;
}
static const GstFormat *
gst_filesrc_get_formats (GstPad * pad)
{
static const GstFormat formats[] = {
GST_FORMAT_BYTES,
0,
};
return formats;
}
static void gst_filesrc_dispose (GObject * object);
static void gst_filesrc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_filesrc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static gboolean gst_filesrc_check_filesize (GstFileSrc * src);
static GstFlowReturn gst_filesrc_get (GstPad * pad, GstBuffer ** buffer);
static GstFlowReturn gst_filesrc_getrange (GstPad * pad, guint64 offset,
guint length, GstBuffer ** buffer);
static gboolean gst_filesrc_srcpad_event (GstPad * pad, GstEvent * event);
static gboolean gst_filesrc_srcpad_query (GstPad * pad, GstQueryType type,
GstFormat * format, gint64 * value);
static gboolean gst_filesrc_activate (GstPad * pad, GstActivateMode mode);
static GstElementStateReturn gst_filesrc_change_state (GstElement * element);
static GstCaps *gst_filesrc_type_find (GstFileSrc * src);
static void gst_filesrc_uri_handler_init (gpointer g_iface,
gpointer iface_data);
static void
_do_init (GType filesrc_type)
{
static const GInterfaceInfo urihandler_info = {
gst_filesrc_uri_handler_init,
NULL,
NULL
};
g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER,
&urihandler_info);
GST_DEBUG_CATEGORY_INIT (gst_filesrc_debug, "filesrc", 0, "filesrc element");
}
GST_BOILERPLATE_FULL (GstFileSrc, gst_filesrc, GstElement, GST_TYPE_ELEMENT,
_do_init);
static void
gst_filesrc_base_init (gpointer g_class)
{
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&srctemplate));
gst_element_class_set_details (gstelement_class, &gst_filesrc_details);
}
static void
gst_filesrc_class_init (GstFileSrcClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
gobject_class = (GObjectClass *) klass;
gobject_class->set_property = gst_filesrc_set_property;
gobject_class->get_property = gst_filesrc_get_property;
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FD,
g_param_spec_int ("fd", "File-descriptor",
"File-descriptor for the file being mmap()d", 0, G_MAXINT, 0,
G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATION,
g_param_spec_string ("location", "File Location",
"Location of the file to read", NULL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BLOCKSIZE,
g_param_spec_ulong ("blocksize", "Block size",
"Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MMAPSIZE,
g_param_spec_ulong ("mmapsize", "mmap() Block Size",
"Size in bytes of mmap()d regions", 0, G_MAXULONG, DEFAULT_MMAPSIZE,
G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOUCH,
g_param_spec_boolean ("touch", "Touch read data",
"Touch data to force disk read", FALSE, G_PARAM_READWRITE));
gobject_class->dispose = gst_filesrc_dispose;
gstelement_class->change_state = gst_filesrc_change_state;
}
static void
gst_filesrc_init (GstFileSrc * src)
{
src->srcpad =
gst_pad_new_from_template (gst_static_pad_template_get (&srctemplate),
"src");
gst_pad_set_getrange_function (src->srcpad, gst_filesrc_getrange);
gst_pad_set_activate_function (src->srcpad, gst_filesrc_activate);
gst_pad_set_event_function (src->srcpad, gst_filesrc_srcpad_event);
gst_pad_set_event_mask_function (src->srcpad, gst_filesrc_get_event_mask);
gst_pad_set_query_function (src->srcpad, gst_filesrc_srcpad_query);
gst_pad_set_query_type_function (src->srcpad, gst_filesrc_get_query_types);
gst_pad_set_formats_function (src->srcpad, gst_filesrc_get_formats);
gst_element_add_pad (GST_ELEMENT (src), src->srcpad);
#ifdef HAVE_MMAP
src->pagesize = getpagesize ();
#endif
src->filename = NULL;
src->fd = 0;
src->filelen = 0;
src->uri = NULL;
src->curoffset = 0;
src->block_size = DEFAULT_BLOCKSIZE;
src->touch = FALSE;
src->mapbuf = NULL;
src->mapsize = DEFAULT_MMAPSIZE; /* default is 4MB */
src->is_regular = FALSE;
}
static void
gst_filesrc_dispose (GObject * object)
{
GstFileSrc *src;
src = GST_FILESRC (object);
g_free (src->filename);
g_free (src->uri);
/* dispose may be called multiple times */
src->filename = NULL;
src->uri = NULL;
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static gboolean
gst_filesrc_set_location (GstFileSrc * src, const gchar * location)
{
/* the element must be stopped in order to do this */
if (GST_STATE (src) != GST_STATE_READY && GST_STATE (src) != GST_STATE_NULL)
return FALSE;
g_free (src->filename);
g_free (src->uri);
/* clear the filename if we get a NULL (is that possible?) */
if (location == NULL) {
src->filename = NULL;
src->uri = NULL;
} else {
src->filename = g_strdup (location);
src->uri = gst_uri_construct ("file", src->filename);
}
g_object_notify (G_OBJECT (src), "location");
gst_uri_handler_new_uri (GST_URI_HANDLER (src), src->uri);
return TRUE;
}
static void
gst_filesrc_set_property (GObject * object, guint prop_id, const GValue * value,
GParamSpec * pspec)
{
GstFileSrc *src;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_FILESRC (object));
src = GST_FILESRC (object);
switch (prop_id) {
case ARG_LOCATION:
gst_filesrc_set_location (src, g_value_get_string (value));
break;
case ARG_BLOCKSIZE:
src->block_size = g_value_get_ulong (value);
g_object_notify (G_OBJECT (src), "blocksize");
break;
case ARG_MMAPSIZE:
if ((src->mapsize % src->pagesize) == 0) {
src->mapsize = g_value_get_ulong (value);
g_object_notify (G_OBJECT (src), "mmapsize");
} else {
GST_INFO_OBJECT (src,
"invalid mapsize, must be a multiple of pagesize, which is %d",
src->pagesize);
}
break;
case ARG_TOUCH:
src->touch = g_value_get_boolean (value);
g_object_notify (G_OBJECT (src), "touch");
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_filesrc_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
GstFileSrc *src;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_FILESRC (object));
src = GST_FILESRC (object);
switch (prop_id) {
case ARG_LOCATION:
g_value_set_string (value, src->filename);
break;
case ARG_FD:
g_value_set_int (value, src->fd);
break;
case ARG_BLOCKSIZE:
g_value_set_ulong (value, src->block_size);
break;
case ARG_MMAPSIZE:
g_value_set_ulong (value, src->mapsize);
break;
case ARG_TOUCH:
g_value_set_boolean (value, src->touch);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
#ifdef HAVE_MMAP
static void
gst_filesrc_free_parent_mmap (GstBuffer * buf)
{
GST_LOG ("freeing mmap()d buffer at %" G_GUINT64_FORMAT "+%u",
GST_BUFFER_OFFSET (buf), GST_BUFFER_SIZE (buf));
#ifdef MADV_DONTNEED
/* madvise to tell the kernel what to do with it */
madvise (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), MADV_DONTNEED);
#endif
/* now unmap the memory */
munmap (GST_BUFFER_DATA (buf), GST_BUFFER_MAXSIZE (buf));
/* cast to unsigned long, since there's no gportable way to print
* guint64 as hex */
GST_LOG ("unmapped region %08lx+%08lx at %p",
(unsigned long) GST_BUFFER_OFFSET (buf),
(unsigned long) GST_BUFFER_MAXSIZE (buf), GST_BUFFER_DATA (buf));
GST_BUFFER_DATA (buf) = NULL;
}
#endif
#ifdef HAVE_MMAP
static GstBuffer *
gst_filesrc_map_region (GstFileSrc * src, off_t offset, size_t size)
{
GstBuffer *buf;
gint retval;
void *mmapregion;
g_return_val_if_fail (offset >= 0, NULL);
GST_LOG_OBJECT (src, "mapping region %08llx+%08lx from file into memory",
offset, (unsigned long) size);
mmapregion = mmap (NULL, size, PROT_READ, MAP_SHARED, src->fd, offset);
if (mmapregion == NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY, (NULL), ("mmap call failed."));
return NULL;
} else if (mmapregion == MAP_FAILED) {
GST_WARNING_OBJECT (src, "mmap (0x%08lx, %d, 0x%llx) failed: %s",
(unsigned long) size, src->fd, offset, strerror (errno));
return NULL;
}
GST_LOG_OBJECT (src, "mapped region %08lx+%08lx from file into memory at %p",
(unsigned long) offset, (unsigned long) size, mmapregion);
/* time to allocate a new mapbuf */
buf = gst_buffer_new ();
/* mmap() the data into this new buffer */
GST_BUFFER_DATA (buf) = mmapregion;
#ifdef MADV_SEQUENTIAL
/* madvise to tell the kernel what to do with it */
retval =
madvise (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), MADV_SEQUENTIAL);
#endif
/* fill in the rest of the fields */
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_READONLY);
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_ORIGINAL);
GST_BUFFER_SIZE (buf) = size;
GST_BUFFER_MAXSIZE (buf) = size;
GST_BUFFER_OFFSET (buf) = offset;
GST_BUFFER_OFFSET_END (buf) = offset + size;
GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_PRIVATE (buf) = src;
GST_BUFFER_FREE_DATA_FUNC (buf) = gst_filesrc_free_parent_mmap;
return buf;
}
#endif
#ifdef HAVE_MMAP
static GstBuffer *
gst_filesrc_map_small_region (GstFileSrc * src, off_t offset, size_t size)
{
size_t mapsize;
off_t mod, mapbase;
GstBuffer *map;
/* printf("attempting to map a small buffer at %d+%d\n",offset,size); */
/* if the offset starts at a non-page boundary, we have to special case */
if ((mod = offset % src->pagesize)) {
GstBuffer *ret;
mapbase = offset - mod;
mapsize =
((size + mod + src->pagesize - 1) / src->pagesize) * src->pagesize;
/* printf("not on page boundaries, resizing map to %d+%d\n",mapbase,mapsize);*/
map = gst_filesrc_map_region (src, mapbase, mapsize);
if (map == NULL)
return NULL;
ret = gst_buffer_create_sub (map, offset - mapbase, size);
GST_BUFFER_OFFSET (ret) = GST_BUFFER_OFFSET (map) + offset - mapbase;
gst_buffer_unref (map);
return ret;
}
return gst_filesrc_map_region (src, offset, size);
}
#endif
#ifdef HAVE_MMAP
/**
* gst_filesrc_get_mmap:
* @src: #GstElement to get data from
*
* Returns: a new #GstData from the mmap'd source.
*/
static GstData *
gst_filesrc_get_mmap (GstFileSrc * src)
{
GstBuffer *buf = NULL;
size_t readsize, mapsize;
off_t readend, mapstart, mapend;
int i;
/* calculate end pointers so we don't have to do so repeatedly later */
readsize = src->block_size;
readend = src->curoffset + src->block_size; /* note this is the byte *after* the read */
mapstart = GST_BUFFER_OFFSET (src->mapbuf);
mapsize = GST_BUFFER_SIZE (src->mapbuf);
mapend = mapstart + mapsize; /* note this is the byte *after* the map */
/* check to see if we're going to overflow the end of the file */
if (src->is_regular) {
if (readend > src->filelen) {
if (!gst_filesrc_check_filesize (src) || readend > src->filelen) {
readsize = src->filelen - src->curoffset;
readend = src->curoffset + readsize;
}
}
}
GST_LOG ("attempting to read %08lx, %08lx, %08lx, %08lx",
(unsigned long) readsize, (unsigned long) readend,
(unsigned long) mapstart, (unsigned long) mapend);
/* if the start is past the mapstart */
if (src->curoffset >= mapstart) {
/* if the end is before the mapend, the buffer is in current mmap region... */
/* ('cause by definition if readend is in the buffer, so's readstart) */
if (readend <= mapend) {
GST_LOG_OBJECT (src,
"read buf %llu+%d lives in current mapbuf %lld+%d, creating subbuffer of mapbuf",
src->curoffset, (int) readsize, mapstart, mapsize);
buf =
gst_buffer_create_sub (src->mapbuf, src->curoffset - mapstart,
readsize);
GST_BUFFER_OFFSET (buf) = src->curoffset;
/* if the start actually is within the current mmap region, map an overlap buffer */
} else if (src->curoffset < mapend) {
GST_LOG_OBJECT (src,
"read buf %llu+%d starts in mapbuf %d+%d but ends outside, creating new mmap",
(unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
(gint) mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
return NULL;
}
/* the only other option is that buffer is totally outside, which means we search for it */
/* now we can assume that the start is *before* the current mmap region */
/* if the readend is past mapstart, we have two options */
} else if (readend >= mapstart) {
/* either the read buffer overlaps the start of the mmap region */
/* or the read buffer fully contains the current mmap region */
/* either way, it's really not relevant, we just create a new region anyway */
GST_LOG_OBJECT (src,
"read buf %llu+%d starts before mapbuf %d+%d, but overlaps it",
(unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
(gint) mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
return NULL;
}
/* then deal with the case where the read buffer is totally outside */
if (buf == NULL) {
/* first check to see if there's a map that covers the right region already */
GST_LOG_OBJECT (src, "searching for mapbuf to cover %llu+%d",
src->curoffset, (int) readsize);
/* if the read buffer crosses a mmap region boundary, create a one-off region */
if ((src->curoffset / src->mapsize) != (readend / src->mapsize)) {
GST_LOG_OBJECT (src,
"read buf %llu+%d crosses a %d-byte boundary, creating a one-off",
src->curoffset, (int) readsize, (int) src->mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
return NULL;
/* otherwise we will create a new mmap region and set it to the default */
} else {
size_t mapsize;
off_t nextmap = src->curoffset - (src->curoffset % src->mapsize);
GST_LOG_OBJECT (src,
"read buf %llu+%d in new mapbuf at %llu+%d, mapping and subbuffering",
src->curoffset, readsize, nextmap, src->mapsize);
/* first, we're done with the old mapbuf */
gst_buffer_unref (src->mapbuf);
mapsize = src->mapsize;
/* double the mapsize as long as the readsize is smaller */
while (readsize + src->curoffset > nextmap + mapsize) {
GST_LOG_OBJECT (src, "readsize smaller then mapsize %08x %d",
readsize, (int) mapsize);
mapsize <<= 1;
}
/* create a new one */
src->mapbuf = gst_filesrc_map_region (src, nextmap, mapsize);
if (src->mapbuf == NULL)
return NULL;
/* subbuffer it */
buf =
gst_buffer_create_sub (src->mapbuf, src->curoffset - nextmap,
readsize);
GST_BUFFER_OFFSET (buf) =
GST_BUFFER_OFFSET (src->mapbuf) + src->curoffset - nextmap;
}
}
/* if we need to touch the buffer (to bring it into memory), do so */
if (src->touch) {
volatile guchar *p = GST_BUFFER_DATA (buf), c;
for (i = 0; i < GST_BUFFER_SIZE (buf); i += src->pagesize)
c = p[i];
}
/* we're done, return the buffer */
g_assert (src->curoffset == GST_BUFFER_OFFSET (buf));
src->curoffset += GST_BUFFER_SIZE (buf);
return GST_DATA (buf);
}
#endif
static GstData *
gst_filesrc_get_read (GstFileSrc * src)
{
GstBuffer *buf = NULL;
size_t readsize;
int ret;
readsize = src->block_size;
/* for regular files, we can use the filesize to check how much we
can read */
if (src->is_regular) {
if (src->curoffset + readsize > src->filelen) {
if (!gst_filesrc_check_filesize (src)
|| src->curoffset + readsize > src->filelen) {
readsize = src->filelen - src->curoffset;
}
}
}
buf = gst_buffer_new_and_alloc (readsize);
g_return_val_if_fail (buf != NULL, NULL);
GST_LOG_OBJECT (src, "Reading %d bytes", readsize);
ret = read (src->fd, GST_BUFFER_DATA (buf), readsize);
if (ret < 0) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
return NULL;
}
/* regular files should have given us what we expected */
if (ret < readsize && src->is_regular) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
("unexpected end of file."));
return NULL;
}
/* other files should eos if they read 0 */
if (ret == 0) {
GST_DEBUG ("non-regular file hits EOS");
gst_buffer_unref (buf);
//gst_element_set_eos (GST_ELEMENT (src));
return GST_DATA (gst_event_new (GST_EVENT_EOS));
}
readsize = ret;
GST_BUFFER_SIZE (buf) = readsize;
GST_BUFFER_MAXSIZE (buf) = readsize;
GST_BUFFER_OFFSET (buf) = src->curoffset;
GST_BUFFER_OFFSET_END (buf) = src->curoffset + readsize;
src->curoffset += readsize;
return GST_DATA (buf);
}
static GstFlowReturn
gst_filesrc_getrange (GstPad * pad, guint64 offset, guint length,
GstBuffer ** buffer)
{
GstFileSrc *src;
src = GST_FILESRC (GST_PAD_PARENT (pad));
src->curoffset = offset;
src->block_size = length;
return gst_filesrc_get (pad, buffer);
}
static GstFlowReturn
gst_filesrc_get (GstPad * pad, GstBuffer ** buffer)
{
GstFileSrc *src;
GstData *data;
src = GST_FILESRC (GST_PAD_PARENT (pad));
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_FILESRC_OPEN),
GST_FLOW_WRONG_STATE);
/* check for flush */
if (src->need_flush) {
src->need_flush = FALSE;
GST_DEBUG_OBJECT (src, "sending flush");
gst_pad_push_event (pad, gst_event_new_flush (TRUE));
}
/* check for seek */
if (src->need_discont) {
GstEvent *event;
GST_DEBUG_OBJECT (src, "sending discont");
event =
gst_event_new_discontinuous (src->need_discont > 1, GST_FORMAT_BYTES,
(guint64) src->curoffset, GST_FORMAT_UNDEFINED);
src->need_discont = 0;
gst_pad_push_event (pad, event);
}
/* check for EOF if it's a regular file */
if (src->is_regular) {
g_assert (src->curoffset <= src->filelen);
if (src->curoffset == src->filelen) {
if (!gst_filesrc_check_filesize (src) || src->curoffset >= src->filelen) {
GST_DEBUG_OBJECT (src, "eos %" G_GINT64_FORMAT " %" G_GINT64_FORMAT,
src->curoffset, src->filelen);
}
//gst_element_set_eos (GST_ELEMENT (src));
gst_pad_push_event (pad, gst_event_new (GST_EVENT_EOS));
return GST_FLOW_WRONG_STATE;
}
}
#ifdef HAVE_MMAP
if (src->using_mmap) {
data = gst_filesrc_get_mmap (src);
} else {
data = gst_filesrc_get_read (src);
}
#else
data = gst_filesrc_get_read (src);
#endif
if (data == NULL) {
GST_DEBUG_OBJECT (src, "could not get data");
return GST_FLOW_ERROR;
}
if (GST_IS_EVENT (data)) {
gst_pad_push_event (pad, GST_EVENT (data));
} else {
*buffer = GST_BUFFER (data);
}
return GST_FLOW_OK;
}
/* TRUE if the filesize of the file was updated */
static gboolean
gst_filesrc_check_filesize (GstFileSrc * src)
{
struct stat stat_results;
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_FILESRC_OPEN), FALSE);
fstat (src->fd, &stat_results);
GST_DEBUG_OBJECT (src,
"checked filesize on %s (was %" G_GUINT64_FORMAT ", is %" G_GUINT64_FORMAT
")", src->filename, src->filelen, (guint64) stat_results.st_size);
if (src->filelen == (guint64) stat_results.st_size)
return FALSE;
src->filelen = stat_results.st_size;
return TRUE;
}
/* open the file and mmap it, necessary to go to READY state */
static gboolean
gst_filesrc_open_file (GstFileSrc * src)
{
g_return_val_if_fail (!GST_FLAG_IS_SET (src, GST_FILESRC_OPEN), FALSE);
if (src->filename == NULL || src->filename[0] == '\0') {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
(_("No file name specified for reading.")), (NULL));
return FALSE;
}
GST_INFO_OBJECT (src, "opening file %s", src->filename);
/* open the file */
src->fd = open (src->filename, O_RDONLY | O_BINARY);
if (src->fd < 0) {
if (errno == ENOENT)
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL),
("No such file \"%s\"", src->filename));
else
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
(_("Could not open file \"%s\" for reading."), src->filename),
GST_ERROR_SYSTEM);
return FALSE;
} else {
/* check if it is a regular file, otherwise bail out */
struct stat stat_results;
fstat (src->fd, &stat_results);
if (S_ISDIR (stat_results.st_mode)) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
(_("\"%s\" is a directory."), src->filename), (NULL));
close (src->fd);
return FALSE;
}
if (S_ISSOCK (stat_results.st_mode)) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
(_("File \"%s\" is a socket."), src->filename), (NULL));
close (src->fd);
return FALSE;
}
/* find the file length */
src->filelen = stat_results.st_size;
src->using_mmap = FALSE;
/* record if it's a regular (hence seekable and lengthable) file */
if (S_ISREG (stat_results.st_mode))
src->is_regular = TRUE;
#ifdef HAVE_MMAP
/* FIXME: maybe we should only try to mmap if it's a regular file */
/* allocate the first mmap'd region if it's a regular file ? */
src->mapbuf = gst_filesrc_map_region (src, 0, src->mapsize);
if (src->mapbuf != NULL) {
GST_DEBUG_OBJECT (src, "using mmap for file");
src->using_mmap = TRUE;
}
#endif
src->curoffset = 0;
GST_FLAG_SET (src, GST_FILESRC_OPEN);
{
GstCaps *caps;
guint64 offset;
guint length;
offset = src->curoffset;
length = src->block_size;
caps = gst_filesrc_type_find (src);
gst_pad_set_caps (src->srcpad, caps);
src->curoffset = offset;
src->block_size = length;
}
}
return TRUE;
}
/* unmap and close the file */
static void
gst_filesrc_close_file (GstFileSrc * src)
{
g_return_if_fail (GST_FLAG_IS_SET (src, GST_FILESRC_OPEN));
/* close the file */
close (src->fd);
/* zero out a lot of our state */
src->fd = 0;
src->filelen = 0;
src->curoffset = 0;
src->is_regular = FALSE;
if (src->mapbuf) {
gst_buffer_unref (src->mapbuf);
src->mapbuf = NULL;
}
GST_FLAG_UNSET (src, GST_FILESRC_OPEN);
}
static void
gst_filesrc_loop (GstPad * pad)
{
GstFileSrc *filesrc;
gboolean result;
GstBuffer *buffer;
filesrc = GST_FILESRC (GST_PAD_PARENT (pad));
GST_STREAM_LOCK (pad);
result = gst_filesrc_get (pad, &buffer);
if (result != GST_FLOW_OK) {
gst_task_pause (GST_RPAD_TASK (pad));
goto done;
}
result = gst_pad_push (pad, buffer);
if (result != GST_FLOW_OK) {
gst_task_pause (GST_RPAD_TASK (pad));
}
done:
GST_STREAM_UNLOCK (pad);
}
static gboolean
gst_filesrc_activate (GstPad * pad, GstActivateMode mode)
{
gboolean result = FALSE;
GstFileSrc *filesrc;
filesrc = GST_FILESRC (GST_OBJECT_PARENT (pad));
switch (mode) {
case GST_ACTIVATE_PUSH:
/* if we have a scheduler we can start the task */
if (GST_ELEMENT_SCHEDULER (filesrc)) {
GST_STREAM_LOCK (pad);
GST_RPAD_TASK (pad) =
gst_scheduler_create_task (GST_ELEMENT_SCHEDULER (filesrc),
(GstTaskFunction) gst_filesrc_loop, pad);
gst_task_start (GST_RPAD_TASK (pad));
result = TRUE;
GST_STREAM_UNLOCK (pad);
}
break;
case GST_ACTIVATE_PULL:
result = TRUE;
break;
case GST_ACTIVATE_NONE:
/* step 1, unblock clock sync (if any) */
/* step 2, make sure streaming finishes */
GST_STREAM_LOCK (pad);
/* step 3, stop the task */
gst_task_stop (GST_RPAD_TASK (pad));
GST_STREAM_UNLOCK (pad);
result = TRUE;
break;
}
return result;
}
static GstElementStateReturn
gst_filesrc_change_state (GstElement * element)
{
GstElementStateReturn result = GST_STATE_SUCCESS;
GstFileSrc *src = GST_FILESRC (element);
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_NULL_TO_READY:
break;
case GST_STATE_READY_TO_NULL:
break;
case GST_STATE_READY_TO_PAUSED:
if (!GST_FLAG_IS_SET (element, GST_FILESRC_OPEN)) {
if (!gst_filesrc_open_file (GST_FILESRC (element)))
return GST_STATE_FAILURE;
}
src->need_discont = 2;
break;
case GST_STATE_PAUSED_TO_PLAYING:
gst_task_start (GST_RPAD_TASK (src->srcpad));
break;
}
result = GST_ELEMENT_CLASS (parent_class)->change_state (element);
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_PLAYING_TO_PAUSED:
gst_task_start (GST_RPAD_TASK (src->srcpad));
break;
case GST_STATE_PAUSED_TO_READY:
if (GST_FLAG_IS_SET (element, GST_FILESRC_OPEN))
gst_filesrc_close_file (GST_FILESRC (element));
break;
default:
break;
}
return result;
}
static gboolean
gst_filesrc_srcpad_query (GstPad * pad, GstQueryType type,
GstFormat * format, gint64 * value)
{
GstFileSrc *src = GST_FILESRC (GST_PAD_PARENT (pad));
if (*format == GST_FORMAT_DEFAULT)
*format = GST_FORMAT_BYTES;
switch (type) {
case GST_QUERY_TOTAL:
if (*format != GST_FORMAT_BYTES) {
return FALSE;
}
if (!src->is_regular)
return FALSE;
gst_filesrc_check_filesize (src);
*value = src->filelen;
break;
case GST_QUERY_POSITION:
switch (*format) {
case GST_FORMAT_BYTES:
*value = src->curoffset;
break;
case GST_FORMAT_PERCENT:
if (src->filelen == 0)
return FALSE;
if (!src->is_regular)
return FALSE;
*value = src->curoffset * GST_FORMAT_PERCENT_MAX / src->filelen;
break;
default:
return FALSE;
}
break;
default:
return FALSE;
break;
}
return TRUE;
}
static gboolean
gst_filesrc_srcpad_event (GstPad * pad, GstEvent * event)
{
GstFileSrc *src = GST_FILESRC (GST_PAD_PARENT (pad));
GST_DEBUG_OBJECT (src, "received event type %d", GST_EVENT_TYPE (event));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEEK:
{
gint64 offset;
if (GST_EVENT_SEEK_FORMAT (event) != GST_FORMAT_BYTES &&
GST_EVENT_SEEK_FORMAT (event) != GST_FORMAT_DEFAULT) {
goto error;
}
if (!src->is_regular) {
GST_DEBUG ("can't handle seek on a non-regular file");
goto error;
}
offset = GST_EVENT_SEEK_OFFSET (event);
switch (GST_EVENT_SEEK_METHOD (event)) {
case GST_SEEK_METHOD_SET:
if (offset < 0) {
goto error;
} else if (offset > src->filelen && (!gst_filesrc_check_filesize (src)
|| offset > src->filelen)) {
src->curoffset = src->filelen;
} else {
src->curoffset = offset;
}
GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
src->curoffset);
break;
case GST_SEEK_METHOD_CUR:
if (offset + src->curoffset > src->filelen &&
(!gst_filesrc_check_filesize (src)
|| offset + src->curoffset > src->filelen)) {
src->curoffset = src->filelen;
} else if (offset + src->curoffset < 0) {
src->curoffset = 0;
} else {
src->curoffset += offset;
}
GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
src->curoffset);
break;
case GST_SEEK_METHOD_END:
if (offset > 0) {
goto error;
} else if (offset > src->filelen && (!gst_filesrc_check_filesize (src)
|| offset > src->filelen)) {
src->curoffset = 0;
} else {
src->curoffset = src->filelen + offset;
}
GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
src->curoffset);
break;
default:
goto error;
break;
}
src->need_discont = 1;
src->need_flush = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH;
break;
}
case GST_EVENT_SIZE:
if (GST_EVENT_SIZE_FORMAT (event) != GST_FORMAT_BYTES) {
goto error;
}
src->block_size = GST_EVENT_SIZE_VALUE (event);
g_object_notify (G_OBJECT (src), "blocksize");
break;
case GST_EVENT_FLUSH:
src->need_flush = TRUE;
break;
default:
goto error;
break;
}
gst_event_unref (event);
return TRUE;
error:
gst_event_unref (event);
return FALSE;
}
typedef struct
{
GstFileSrc *src;
guint best_probability;
GstCaps *caps;
GstBuffer *buffer;
}
FileSrcTypeFind;
static guint8 *
filesrc_find_peek (gpointer data, gint64 offset, guint size)
{
FileSrcTypeFind *find;
GstBuffer *buffer;
GstFileSrc *src;
if (size == 0)
return NULL;
find = (FileSrcTypeFind *) data;
src = find->src;
if (offset < 0) {
offset += src->filelen;
}
buffer = NULL;
gst_filesrc_getrange (src->srcpad, offset, size, &buffer);
if (find->buffer) {
gst_buffer_unref (find->buffer);
}
find->buffer = buffer;
return GST_BUFFER_DATA (buffer);
}
static void
filesrc_find_suggest (gpointer data, guint probability, const GstCaps * caps)
{
FileSrcTypeFind *find = (FileSrcTypeFind *) data;
if (probability > find->best_probability) {
gst_caps_replace (&find->caps, gst_caps_copy (caps));
find->best_probability = probability;
}
}
static GstCaps *
gst_filesrc_type_find (GstFileSrc * src)
{
GstTypeFind gst_find;
FileSrcTypeFind find;
GList *walk, *type_list = NULL;
GstCaps *result = NULL;
walk = type_list = gst_type_find_factory_get_list ();
find.src = src;
find.best_probability = 0;
find.caps = NULL;
find.buffer = NULL;
gst_find.data = &find;
gst_find.peek = filesrc_find_peek;
gst_find.suggest = filesrc_find_suggest;
gst_find.get_length = NULL;
while (walk) {
GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (walk->data);
gst_type_find_factory_call_function (factory, &gst_find);
if (find.best_probability >= GST_TYPE_FIND_MAXIMUM)
break;
walk = g_list_next (walk);
}
if (find.best_probability > 0)
result = find.caps;
return result;
}
/*** GSTURIHANDLER INTERFACE *************************************************/
static guint
gst_filesrc_uri_get_type (void)
{
return GST_URI_SRC;
}
static gchar **
gst_filesrc_uri_get_protocols (void)
{
static gchar *protocols[] = { "file", NULL };
return protocols;
}
static const gchar *
gst_filesrc_uri_get_uri (GstURIHandler * handler)
{
GstFileSrc *src = GST_FILESRC (handler);
return src->uri;
}
static gboolean
gst_filesrc_uri_set_uri (GstURIHandler * handler, const gchar * uri)
{
gchar *protocol, *location;
gboolean ret;
GstFileSrc *src = GST_FILESRC (handler);
protocol = gst_uri_get_protocol (uri);
if (strcmp (protocol, "file") != 0) {
g_free (protocol);
return FALSE;
}
g_free (protocol);
location = gst_uri_get_location (uri);
ret = gst_filesrc_set_location (src, location);
g_free (location);
return ret;
}
static void
gst_filesrc_uri_handler_init (gpointer g_iface, gpointer iface_data)
{
GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
iface->get_type = gst_filesrc_uri_get_type;
iface->get_protocols = gst_filesrc_uri_get_protocols;
iface->get_uri = gst_filesrc_uri_get_uri;
iface->set_uri = gst_filesrc_uri_set_uri;
}
Reference in a new issue View git blame Copy permalink