/* GStreamer * Copyright (C) 1999,2000 Erik Walthinsen * 2000 Wim Taymans * * 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 #include "gstfilesrc.h" #include #include #include #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_MMAP #include #endif #include #include #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 "); #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; }