--- /dev/null
+/* GStreamer
+ * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
+ * 2000 Wim Taymans <wtay@chello.be>
+ * 2001 Bastien Nocera <hadess@hadess.net>
+ *
+ * gstgnomevfssink.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.
+ */
+
+
+#include <gst/gst.h>
+#include <libgnomevfs/gnome-vfs.h>
+
+GstElementDetails gst_gnomevfssink_details;
+
+
+#define GST_TYPE_GNOMEVFSSINK \
+ (gst_gnomevfssink_get_type())
+#define GST_GNOMEVFSSINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GNOMEVFSSINK,GstGnomeVFSSink))
+#define GST_GNOMEVFSSINK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GNOMEVFSSINK,GstGnomeVFSSinkClass))
+#define GST_IS_GNOMEVFSSINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GNOMEVFSSINK))
+#define GST_IS_GNOMEVFSSINK_CLASS(obj) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GNOMEVFSSINK))
+
+typedef struct _GstGnomeVFSSink GstGnomeVFSSink;
+typedef struct _GstGnomeVFSSinkClass GstGnomeVFSSinkClass;
+
+typedef enum {
+ GST_GNOMEVFSSINK_OPEN = GST_ELEMENT_FLAG_LAST,
+
+ GST_GNOMEVFSSINK_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
+} GstGnomeVFSSinkFlags;
+
+struct _GstGnomeVFSSink {
+ GstElement element;
+
+ /* filename */
+ gchar *filename;
+ /* uri */
+ GnomeVFSURI *uri;
+ /* handle */
+ GnomeVFSHandle *handle;
+ /* wether to erase a file or not */
+ gboolean erase;
+};
+
+struct _GstGnomeVFSSinkClass {
+ GstElementClass parent_class;
+
+ /* signals */
+ void (*handoff) (GstElement *element,GstPad *pad);
+ void (*erase_ask) (GstElement *element,GstPad *pad);
+};
+
+GType gst_gnomevfssink_get_type(void);
+
+GstElementDetails gst_gnomevfssink_details = {
+ "GnomeVFS Sink",
+ "Sink",
+ "GnomeVFS hole for data",
+ VERSION,
+ "Bastien Nocera <hadess@hadess.net>",
+ "(C) 2001"
+};
+
+
+/* GnomeVFSSink signals and args */
+enum {
+ /* FILL ME */
+ SIGNAL_HANDOFF,
+ SIGNAL_ERASE_ASK,
+ LAST_SIGNAL
+};
+
+enum {
+ ARG_0,
+ ARG_LOCATION,
+ ARG_ERASE
+};
+
+
+static void gst_gnomevfssink_class_init (GstGnomeVFSSinkClass *klass);
+static void gst_gnomevfssink_init (GstGnomeVFSSink *gnomevfssink);
+
+static void gst_gnomevfssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void gst_gnomevfssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static gboolean gst_gnomevfssink_open_file (GstGnomeVFSSink *sink);
+static void gst_gnomevfssink_close_file (GstGnomeVFSSink *sink);
+
+static void gst_gnomevfssink_chain (GstPad *pad,GstBuffer *buf);
+
+static GstElementStateReturn gst_gnomevfssink_change_state (GstElement *element);
+
+static GstElementClass *parent_class = NULL;
+static guint gst_gnomevfssink_signals[LAST_SIGNAL] = { 0 };
+
+GType
+gst_gnomevfssink_get_type (void)
+{
+ static GType gnomevfssink_type = 0;
+
+ if (!gnomevfssink_type) {
+ static const GTypeInfo gnomevfssink_info = {
+ sizeof(GstGnomeVFSSinkClass), NULL,
+ NULL,
+ (GClassInitFunc)gst_gnomevfssink_class_init,
+ NULL,
+ NULL,
+ sizeof(GstGnomeVFSSink),
+ 0,
+ (GInstanceInitFunc)gst_gnomevfssink_init,
+ };
+ gnomevfssink_type = g_type_register_static (GST_TYPE_ELEMENT, "GstGnomeVFSSink", &gnomevfssink_info, 0);
+ }
+ return gnomevfssink_type;
+}
+
+static void
+gst_gnomevfssink_class_init (GstGnomeVFSSinkClass *klass)
+{
+ GObjectClass *gobject_class;
+ GstElementClass *gstelement_class;
+
+ gobject_class = (GObjectClass*)klass;
+ gstelement_class = (GstElementClass*)klass;
+
+ parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+
+
+ gst_element_install_std_props (
+ GST_ELEMENT_CLASS (klass),
+ "location", ARG_LOCATION, G_PARAM_READWRITE,
+ NULL);
+
+ gst_gnomevfssink_signals[SIGNAL_HANDOFF] =
+ g_signal_new ("handoff", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstGnomeVFSSinkClass, handoff), NULL, NULL,
+ g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+
+ gst_gnomevfssink_signals[SIGNAL_ERASE_ASK] =
+ g_signal_new ("erase-ask", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GstGnomeVFSSinkClass, erase_ask), NULL, NULL,
+ g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+
+
+ gobject_class->set_property = gst_gnomevfssink_set_property;
+ gobject_class->get_property = gst_gnomevfssink_get_property;
+
+ gstelement_class->change_state = gst_gnomevfssink_change_state;
+
+ /* gnome vfs engine init */
+ if (gnome_vfs_initialized() == FALSE)
+ gnome_vfs_init();
+}
+
+static void
+gst_gnomevfssink_init (GstGnomeVFSSink *gnomevfssink)
+{
+ GstPad *pad;
+ pad = gst_pad_new ("sink", GST_PAD_SINK);
+ gst_element_add_pad (GST_ELEMENT (gnomevfssink), pad);
+ gst_pad_set_chain_function (pad, gst_gnomevfssink_chain);
+
+ gnomevfssink->filename = NULL;
+ gnomevfssink->uri = NULL;
+ gnomevfssink->handle = NULL;
+ gnomevfssink->erase = FALSE;
+}
+
+static void
+gst_gnomevfssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+ GstGnomeVFSSink *sink;
+
+ /* it's not null if we got it, but it might not be ours */
+ sink = GST_GNOMEVFSSINK (object);
+
+ switch (prop_id) {
+ case ARG_LOCATION:
+ if (sink->filename)
+ g_free (sink->filename);
+ if (sink->uri)
+ g_free (sink->uri);
+ if (sink->handle)
+ g_free (sink->handle);
+ sink->filename = g_strdup (g_value_get_string (value));
+ break;
+ case ARG_ERASE:
+ sink->erase = g_value_get_boolean (value);
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gst_gnomevfssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+ GstGnomeVFSSink *sink;
+
+ /* it's not null if we got it, but it might not be ours */
+ g_return_if_fail (GST_IS_GNOMEVFSSINK (object));
+
+ sink = GST_GNOMEVFSSINK (object);
+
+ switch (prop_id) {
+ case ARG_LOCATION:
+ g_value_set_string (value, sink->filename);
+ break;
+ case ARG_ERASE:
+ g_value_set_boolean (value, sink->erase);
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static gboolean
+gst_gnomevfssink_open_file (GstGnomeVFSSink *sink)
+{
+ GnomeVFSResult result;
+
+ g_return_val_if_fail (!GST_FLAG_IS_SET (sink, GST_GNOMEVFSSINK_OPEN), FALSE);
+
+ /* create the GnomeVFSURI from the url */
+ sink->uri = gnome_vfs_uri_new(sink->filename);
+ if (!sink->uri) {
+ perror ("open");
+ gst_element_error (GST_ELEMENT (sink), g_strconcat("opening file \"", sink->filename, "\"", NULL));
+ return FALSE;
+ }
+
+ /* open the file */
+ result = gnome_vfs_create_uri(&(sink->handle), sink->uri,
+ GNOME_VFS_OPEN_WRITE, sink->erase,
+ GNOME_VFS_PERM_USER_READ | GNOME_VFS_PERM_USER_WRITE
+ | GNOME_VFS_PERM_GROUP_READ);
+ GST_DEBUG (0, "open: %s\n", gnome_vfs_result_to_string(result));
+ if (result != GNOME_VFS_OK) {
+ if (sink->erase == FALSE) {
+ g_signal_emit (G_OBJECT (sink),
+ gst_gnomevfssink_signals[SIGNAL_ERASE_ASK], 0,
+ sink->erase);
+ }
+ perror ("open");
+ gst_element_error (GST_ELEMENT (sink), g_strconcat("opening file \"", sink->filename, "\"", NULL));
+ return FALSE;
+ }
+
+ GST_FLAG_SET (sink, GST_GNOMEVFSSINK_OPEN);
+
+ return TRUE;
+}
+
+static void
+gst_gnomevfssink_close_file (GstGnomeVFSSink *sink)
+{
+ GnomeVFSResult result;
+
+ g_return_if_fail (GST_FLAG_IS_SET (sink, GST_GNOMEVFSSINK_OPEN));
+
+ /* close the file */
+ result = gnome_vfs_close(sink->handle);
+
+ /* zero out the handle */
+ if (sink->handle)
+ g_free (sink->handle);
+
+ if (result != GNOME_VFS_OK)
+ {
+ perror ("close");
+ gst_element_error (GST_ELEMENT (sink), g_strconcat("closing file \"", sink->filename, "\"", NULL));
+ }
+ else {
+ GST_FLAG_UNSET (sink, GST_GNOMEVFSSINK_OPEN);
+ }
+}
+
+/**
+ * gst_gnomevfssink_chain:
+ * @pad: the pad this gnomevfssink is connected to
+ * @buf: the buffer that has to be absorbed
+ *
+ * take the buffer from the pad and write to file if it's open
+ */
+static void
+gst_gnomevfssink_chain (GstPad *pad, GstBuffer *buf)
+{
+ GstGnomeVFSSink *sink;
+ GnomeVFSResult result;
+ GnomeVFSFileSize bytes_written;
+
+ g_return_if_fail (pad != NULL);
+ g_return_if_fail (GST_IS_PAD (pad));
+ g_return_if_fail (buf != NULL);
+
+ sink = GST_GNOMEVFSSINK (gst_pad_get_parent (pad));
+
+ if (GST_FLAG_IS_SET (sink, GST_GNOMEVFSSINK_OPEN))
+ {
+ result = gnome_vfs_write(sink->handle, GST_BUFFER_DATA(buf), GST_BUFFER_SIZE (buf), &bytes_written);
+ GST_DEBUG (0, "write: %s, written_bytes: %Lu\n", gnome_vfs_result_to_string(result), bytes_written);
+ if (bytes_written < GST_BUFFER_SIZE (buf))
+ {
+ printf ("gnomevfssink : Warning : %d bytes should be written, only %Lu bytes written\n",
+ GST_BUFFER_SIZE (buf), bytes_written);
+ }
+ }
+ gst_buffer_unref (buf);
+
+ g_signal_emit (G_OBJECT (sink), gst_gnomevfssink_signals[SIGNAL_HANDOFF], 0,
+ sink);
+}
+
+static GstElementStateReturn
+gst_gnomevfssink_change_state (GstElement *element)
+{
+ g_return_val_if_fail (GST_IS_GNOMEVFSSINK (element), GST_STATE_FAILURE);
+
+ if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
+ if (GST_FLAG_IS_SET (element, GST_GNOMEVFSSINK_OPEN))
+ gst_gnomevfssink_close_file (GST_GNOMEVFSSINK (element));
+ } else {
+ if (!GST_FLAG_IS_SET (element, GST_GNOMEVFSSINK_OPEN)) {
+ if (!gst_gnomevfssink_open_file (GST_GNOMEVFSSINK (element)))
+ return GST_STATE_FAILURE;
+ }
+ }
+
+ if (GST_ELEMENT_CLASS (parent_class)->change_state)
+ return GST_ELEMENT_CLASS (parent_class)->change_state (element);
+
+ return GST_STATE_SUCCESS;
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+ GstElementFactory *factory;
+
+ /* create an elementfactory for the aasink element */
+ factory = gst_elementfactory_new("gnomevfssink", GST_TYPE_GNOMEVFSSINK,
+ &gst_gnomevfssink_details);
+ g_return_val_if_fail(factory != NULL, FALSE);
+
+ gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+ return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+ GST_VERSION_MAJOR,
+ GST_VERSION_MINOR,
+ "gnomevfssink",
+ plugin_init
+};
--- /dev/null
+/* GStreamer
+ * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
+ * 2000 Wim Taymans <wtay@chello.be>
+ * 2001 Bastien Nocera <hadess@hadess.net>
+ *
+ * gnomevfssrc.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.
+ */
+
+#define BROKEN_SIG 1
+/*#undef BROKEN_SIG */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include <gst/gst.h>
+#include <libgnomevfs/gnome-vfs.h>
+
+GstElementDetails gst_gnomevfssrc_details;
+
+#define GST_TYPE_GNOMEVFSSRC \
+ (gst_gnomevfssrc_get_type())
+#define GST_GNOMEVFSSRC(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GNOMEVFSSRC,GstGnomeVFSSrc))
+#define GST_GNOMEVFSSRC_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GNOMEVFSSRC,GstGnomeVFSSrcClass))
+#define GST_IS_GNOMEVFSSRC(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GNOMEVFSSRC))
+#define GST_IS_GNOMEVFSSRC_CLASS(obj) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GNOMEVFSSRC))
+
+typedef enum {
+ GST_GNOMEVFSSRC_OPEN = GST_ELEMENT_FLAG_LAST,
+
+ GST_GNOMEVFSSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
+} GstGnomeVFSSrcFlags;
+
+typedef struct _GstGnomeVFSSrc GstGnomeVFSSrc;
+typedef struct _GstGnomeVFSSrcClass GstGnomeVFSSrcClass;
+
+struct _GstGnomeVFSSrc {
+ GstElement element;
+ /* pads */
+ GstPad *srcpad;
+
+ /* filename */
+ gchar *filename;
+ /* is it a local file ? */
+ gboolean is_local;
+ /* uri */
+ GnomeVFSURI *uri;
+
+ /* handle */
+ GnomeVFSHandle *handle;
+
+ /* local filename */
+ gchar *local_name;
+ /* fd for local file fallback */
+ gint fd;
+ /* mmap */
+ guchar *map; /* where the file is mapped to */
+
+ /* details for fallback synchronous read */
+ GnomeVFSFileSize size;
+ GnomeVFSFileOffset curoffset; /* current offset in file */
+ gulong bytes_per_read; /* bytes per read */
+ gboolean new_seek;
+};
+
+struct _GstGnomeVFSSrcClass {
+ GstElementClass parent_class;
+#ifdef BROKEN_SIG
+ void (*eos_hack) (GstGnomeVFSSrc * src);
+#endif
+};
+
+GstElementDetails gst_gnomevfssrc_details = {
+ "GnomeVFS Source",
+ "Source/File",
+ "Read from any GnomeVFS file",
+ VERSION,
+ "Bastien Nocera <hadess@hadess.net>",
+ "(C) 2001",
+};
+
+/* GnomeVFSSrc signals and args */
+enum {
+#ifdef BROKEN_SIG
+ EOS_HACK,
+#endif
+ LAST_SIGNAL
+};
+
+enum {
+ ARG_0,
+ ARG_LOCATION,
+ ARG_BYTESPERREAD,
+ ARG_OFFSET,
+ ARG_FILESIZE,
+};
+
+GType gst_gnomevfssrc_get_type(void);
+
+static void gst_gnomevfssrc_class_init(GstGnomeVFSSrcClass *klass);
+static void gst_gnomevfssrc_init(GstGnomeVFSSrc *gnomevfssrc);
+
+static void gst_gnomevfssrc_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void gst_gnomevfssrc_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static GstBuffer *gst_gnomevfssrc_get(GstPad *pad);
+
+static GstElementStateReturn gst_gnomevfssrc_change_state(GstElement *element);
+
+static void gst_gnomevfssrc_close_file(GstGnomeVFSSrc *src);
+static gboolean gst_gnomevfssrc_open_file(GstGnomeVFSSrc *src);
+
+
+static GstElementClass *parent_class = NULL;
+#ifdef BROKEN_SIG
+static guint gst_gnomevfssrc_signals[LAST_SIGNAL] = { 0 };
+#endif
+
+GType gst_gnomevfssrc_get_type(void)
+{
+ static GType gnomevfssrc_type = 0;
+
+ if (!gnomevfssrc_type) {
+ static const GTypeInfo gnomevfssrc_info = {
+ sizeof(GstGnomeVFSSrcClass), NULL,
+ NULL,
+ (GClassInitFunc) gst_gnomevfssrc_class_init,
+ NULL,
+ NULL,
+ sizeof(GstGnomeVFSSrc),
+ 0,
+ (GInstanceInitFunc) gst_gnomevfssrc_init,
+ };
+ gnomevfssrc_type =
+ g_type_register_static(GST_TYPE_ELEMENT, "GstGnomeVFSSrc", &gnomevfssrc_info, 0);
+ }
+ return gnomevfssrc_type;
+}
+
+static void gst_gnomevfssrc_class_init(GstGnomeVFSSrcClass *klass)
+{
+ GObjectClass *gobject_class;
+ GstElementClass *gstelement_class;
+
+ gobject_class = (GObjectClass *) klass;
+ gstelement_class = (GstElementClass *) klass;
+
+ parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+ gst_element_install_std_props (
+ GST_ELEMENT_CLASS (klass),
+ "offset", ARG_OFFSET, G_PARAM_READWRITE,
+ "filesize", ARG_FILESIZE, G_PARAM_READABLE,
+ "bytesperread", ARG_BYTESPERREAD, G_PARAM_READWRITE,
+ "location", ARG_LOCATION, G_PARAM_READWRITE,
+ NULL);
+
+#ifdef BROKEN_SIG
+ gst_gnomevfssrc_signals[EOS_HACK] =
+ g_signal_new("eos-hack", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET(GstGnomeVFSSrcClass, eos_hack), NULL, NULL,
+ g_cclosure_marshal_VOID__VOID, G_TYPE_NONE,0);
+
+#endif /* BROKEN_SIG */
+
+ /*FIXME was for the old cothread scheduling code */
+/* gobject_class->set_property = gst_gnomevfssrc_set_property; */
+/* gobject_class->get_property = gst_gnomevfssrc_get_property; */
+ gstelement_class->set_property = gst_gnomevfssrc_set_property;
+ gstelement_class->get_property = gst_gnomevfssrc_get_property;
+
+ gstelement_class->change_state = gst_gnomevfssrc_change_state;
+
+ /* gnome vfs engine init */
+ if (gnome_vfs_initialized() == FALSE)
+ gnome_vfs_init();
+}
+
+static void gst_gnomevfssrc_init(GstGnomeVFSSrc *gnomevfssrc)
+{
+/* GST_FLAG_SET (gnomevfssrc, GST_SRC_); */
+
+ gnomevfssrc->srcpad = gst_pad_new("src", GST_PAD_SRC);
+ gst_pad_set_get_function(gnomevfssrc->srcpad, gst_gnomevfssrc_get);
+ gst_element_add_pad(GST_ELEMENT(gnomevfssrc), gnomevfssrc->srcpad);
+
+ gnomevfssrc->filename = NULL;
+ gnomevfssrc->is_local = FALSE;
+ gnomevfssrc->uri = NULL;
+ gnomevfssrc->handle = NULL;
+ gnomevfssrc->fd = 0;
+ gnomevfssrc->curoffset = 0;
+ gnomevfssrc->bytes_per_read = 4096;
+ gnomevfssrc->new_seek = FALSE;
+}
+
+
+static void gst_gnomevfssrc_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+ GstGnomeVFSSrc *src;
+
+ /* it's not null if we got it, but it might not be ours */
+ g_return_if_fail(GST_IS_GNOMEVFSSRC(object));
+
+ src = GST_GNOMEVFSSRC(object);
+
+ switch (prop_id) {
+ case ARG_LOCATION:
+ /* the element must be stopped or paused in order to do this */
+ g_return_if_fail((GST_STATE(src) < GST_STATE_PLAYING)
+ || (GST_STATE(src) == GST_STATE_PAUSED));
+
+ if (src->filename)
+ g_free(src->filename);
+
+ /* clear the filename if we get a NULL (is that possible?) */
+ if (g_value_get_string (value) == NULL) {
+ gst_element_set_state(GST_ELEMENT(object),
+ GST_STATE_NULL);
+ src->filename = NULL;
+ } else {
+ /* otherwise set the new filename */
+ src->filename = g_strdup(g_value_get_string (value));
+ }
+
+ if ((GST_STATE(src) == GST_STATE_PAUSED)
+ && (src->filename != NULL)) {
+ gst_gnomevfssrc_close_file(src);
+ gst_gnomevfssrc_open_file(src);
+ }
+ break;
+ case ARG_BYTESPERREAD:
+ src->bytes_per_read = g_value_get_int (value);
+ break;
+ case ARG_OFFSET:
+ src->curoffset = g_value_get_long (value);
+ src->new_seek = TRUE;
+ break;
+ default:
+ break;
+ }
+}
+
+static void gst_gnomevfssrc_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+ GstGnomeVFSSrc *src;
+
+ /* it's not null if we got it, but it might not be ours */
+ g_return_if_fail(GST_IS_GNOMEVFSSRC(object));
+
+ src = GST_GNOMEVFSSRC(object);
+
+ switch (prop_id) {
+ case ARG_LOCATION:
+ g_value_set_string (value, src->filename);
+ break;
+ case ARG_BYTESPERREAD:
+ g_value_set_int (value, src->bytes_per_read);
+ break;
+ case ARG_OFFSET:
+ g_value_set_long (value, src->curoffset);
+ break;
+ case ARG_FILESIZE:
+ g_value_set_long (value, src->size);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+/**
+ * gst_gnomevfssrc_get:
+ * @pad: #GstPad to push a buffer from
+ *
+ * Push a new buffer from the gnomevfssrc at the current offset.
+ */
+static GstBuffer *gst_gnomevfssrc_get(GstPad *pad)
+{
+ GstGnomeVFSSrc *src;
+ GnomeVFSResult result = 0;
+ GstBuffer *buf;
+ GnomeVFSFileSize readbytes;
+
+ g_return_val_if_fail(pad != NULL, NULL);
+ src = GST_GNOMEVFSSRC(gst_pad_get_parent(pad));
+ g_return_val_if_fail(GST_FLAG_IS_SET(src, GST_GNOMEVFSSRC_OPEN),
+ NULL);
+
+ /* deal with EOF state */
+ if ((src->curoffset >= src->size) && (src->size != 0))
+ {
+#ifdef BROKEN_SIG
+ g_signal_emit(G_OBJECT(src),
+ gst_gnomevfssrc_signals[EOS_HACK], 0);
+#endif /* BROKEN_SIG */
+ /*gst_pad_set_eos (pad); */
+ return NULL;
+ }
+
+ /* create the buffer */
+ /* FIXME: should eventually use a bufferpool for this */
+ buf = gst_buffer_new();
+ g_return_val_if_fail(buf, NULL);
+
+ /* read it in from the file */
+ if (src->is_local)
+ {
+ /* simply set the buffer to point to the correct region of the
+ * file */
+ GST_BUFFER_DATA (buf) = src->map + src->curoffset;
+ GST_BUFFER_OFFSET (buf) = src->curoffset;
+ GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
+
+ if ((src->curoffset + src->bytes_per_read) > src->size)
+ {
+ GST_BUFFER_SIZE (buf) = src->size - src->curoffset;
+ /* set the buffer's EOF bit here */
+#ifdef BROKEN_SIG
+ g_signal_emit(G_OBJECT(src),
+ gst_gnomevfssrc_signals[EOS_HACK], 0);
+#endif /* BROKEN_SIG */
+ GST_BUFFER_FLAG_SET(buf, GST_BUFFER_EOS);
+ } else {
+ GST_BUFFER_SIZE (buf) = src->bytes_per_read;
+ }
+
+ src->curoffset += GST_BUFFER_SIZE (buf);
+
+ if (src->new_seek)
+ {
+ GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH);
+ GST_DEBUG (0,"new seek\n");
+ src->new_seek = FALSE;
+ }
+ } else {
+ /* allocate the space for the buffer data */
+ GST_BUFFER_DATA(buf) = g_malloc(src->bytes_per_read);
+ g_return_val_if_fail(GST_BUFFER_DATA(buf) != NULL, NULL);
+
+ if (src->new_seek)
+ {
+ result = gnome_vfs_seek(src->handle,
+ GNOME_VFS_SEEK_START, src->curoffset);
+ GST_DEBUG(0, "new_seek: %s\n",
+ gnome_vfs_result_to_string(result));
+ GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH);
+ src->new_seek = FALSE;
+ }
+
+ result = gnome_vfs_read(src->handle, GST_BUFFER_DATA(buf),
+ src->bytes_per_read, &readbytes);
+
+ GST_DEBUG(0, "read: %s, readbytes: %Lu\n",
+ gnome_vfs_result_to_string(result), readbytes);
+ /* deal with EOS */
+ if (readbytes == 0)
+ {
+ gst_buffer_unref(buf);
+ GST_BUFFER_FLAG_SET(buf, GST_BUFFER_EOS);
+ gst_element_signal_eos(GST_ELEMENT(src));
+#ifdef BROKEN_SIG
+ g_signal_emit(G_OBJECT(src),
+ gst_gnomevfssrc_signals[EOS_HACK], 0);
+#endif /* BROKEN_SIG */
+ return NULL;
+ }
+
+ /* if we didn't get as many bytes as we asked for, we're at
+ * EOF */
+ if (readbytes < src->bytes_per_read)
+ {
+ /* set the buffer's EOF bit here */
+ GST_BUFFER_FLAG_SET(buf, GST_BUFFER_EOS);
+#ifdef BROKEN_SIG
+ g_signal_emit(G_OBJECT(src),
+ gst_gnomevfssrc_signals[EOS_HACK], 0);
+#endif /* BROKEN_SIG */
+ }
+ GST_BUFFER_OFFSET(buf) = src->curoffset;
+ GST_BUFFER_SIZE(buf) = readbytes;
+ src->curoffset += readbytes;
+
+ }
+
+ /* we're done, return the buffer */
+ return buf;
+}
+
+/* open the file and mmap it, necessary to go to READY state */
+static gboolean gst_gnomevfssrc_open_file(GstGnomeVFSSrc *src)
+{
+ GnomeVFSResult result;
+
+ g_return_val_if_fail(!GST_FLAG_IS_SET(src, GST_GNOMEVFSSRC_OPEN),
+ FALSE);
+
+ /* create the uri */
+ src->uri = gnome_vfs_uri_new(src->filename);
+ if (!src->uri) {
+ perror("open");
+ gst_element_error(GST_ELEMENT(src),
+ g_strconcat("creating uri \"",
+ src->filename, "\"", NULL));
+ return FALSE;
+ }
+
+ /* open the file using open() if the file is local */
+ src->is_local = gnome_vfs_uri_is_local(src->uri);
+
+ if (src->is_local) {
+ src->local_name =
+ gnome_vfs_get_local_path_from_uri(src->filename);
+ src->fd = open(src->local_name, O_RDONLY);
+ if (src->fd < 0)
+ {
+ perror("open");
+ gst_element_error(GST_ELEMENT(src),
+ g_strconcat("opening local file \"",
+ src->filename, "\"",
+ NULL));
+ return FALSE;
+ }
+
+ /* find the file length */
+ src->size = lseek (src->fd, 0, SEEK_END);
+ lseek (src->fd, 0, SEEK_SET);
+ src->map = mmap (NULL, src->size, PROT_READ, MAP_SHARED,
+ src->fd, 0);
+ madvise (src->map,src->size, 2);
+ /* collapse state if that failed */
+ if (src->map == NULL)
+ {
+ gst_gnomevfssrc_close_file(src);
+ gst_element_error (GST_ELEMENT (src),"mmapping file");
+ return FALSE;
+ }
+
+ src->new_seek = TRUE;
+ } else {
+ result =
+ gnome_vfs_open_uri(&(src->handle), src->uri,
+ GNOME_VFS_OPEN_READ);
+ if (result != GNOME_VFS_OK)
+ {
+ perror("open");
+ gst_element_error(GST_ELEMENT(src),
+ g_strconcat("opening vfs file \"",
+ src->filename, "\": ",
+ gnome_vfs_result_to_string(result),
+ NULL));
+ return FALSE;
+ }
+
+ /* find the file length */
+ {
+ GnomeVFSResult size_result;
+ GnomeVFSFileInfo *info;
+
+ info = gnome_vfs_file_info_new ();
+ size_result = gnome_vfs_get_file_info_uri(src->uri,
+ info, GNOME_VFS_FILE_INFO_DEFAULT);
+
+ if (size_result != GNOME_VFS_OK)
+ src->size = 0;
+ else
+ src->size = info->size;
+
+ gnome_vfs_file_info_unref(info);
+ }
+
+ GST_DEBUG(0, "open %s\n", gnome_vfs_result_to_string(result));
+ }
+
+ GST_FLAG_SET(src, GST_GNOMEVFSSRC_OPEN);
+
+ return TRUE;
+}
+
+/* unmap and close the file */
+static void gst_gnomevfssrc_close_file(GstGnomeVFSSrc *src)
+{
+ g_return_if_fail(GST_FLAG_IS_SET(src, GST_GNOMEVFSSRC_OPEN));
+
+ /* close the file */
+ if (src->is_local)
+ {
+ /* unmap the file from memory */
+ munmap (src->map, src->size);
+ close(src->fd);
+ } else {
+ gnome_vfs_close(src->handle);
+ }
+
+ /* zero out a lot of our state */
+ src->is_local = FALSE;
+ if (src->uri)
+ g_free(src->uri);
+ if (src->handle)
+ g_free(src->handle);
+ if (src->local_name)
+ g_free(src->local_name);
+ src->fd = 0;
+ src->map = NULL;
+ src->size = 0;
+ src->curoffset = 0;
+ src->new_seek = FALSE;
+
+ GST_FLAG_UNSET(src, GST_GNOMEVFSSRC_OPEN);
+}
+
+static GstElementStateReturn gst_gnomevfssrc_change_state(GstElement *element)
+{
+ g_return_val_if_fail(GST_IS_GNOMEVFSSRC(element),
+ GST_STATE_FAILURE);
+
+ if (GST_STATE_TRANSITION(element) == GST_STATE_NULL_TO_READY) {
+ if (!GST_FLAG_IS_SET(element, GST_GNOMEVFSSRC_OPEN)) {
+ if (!gst_gnomevfssrc_open_file
+ (GST_GNOMEVFSSRC(element)))
+ return GST_STATE_FAILURE;
+ }
+ } else if (GST_STATE_TRANSITION(element) ==
+ GST_STATE_READY_TO_NULL) {
+ if (GST_FLAG_IS_SET(element, GST_GNOMEVFSSRC_OPEN))
+ gst_gnomevfssrc_close_file(GST_GNOMEVFSSRC
+ (element));
+ }
+
+ if (GST_ELEMENT_CLASS(parent_class)->change_state)
+ return GST_ELEMENT_CLASS(parent_class)->
+ change_state(element);
+
+ return GST_STATE_SUCCESS;
+}
+
+static gboolean plugin_init(GModule *module, GstPlugin *plugin)
+{
+ GstElementFactory *factory;
+
+ /* create an elementfactory for the aasink element */
+ factory =
+ gst_elementfactory_new("gnomevfssrc", GST_TYPE_GNOMEVFSSRC,
+ &gst_gnomevfssrc_details);
+ g_return_val_if_fail(factory != NULL, FALSE);
+
+ gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+ return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+ GST_VERSION_MAJOR,
+ GST_VERSION_MINOR,
+ "gnomevfssrc",
+ plugin_init
+};
projects / platform / upstream / gstreamer.git / commitdiff