mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-09-27 14:31:01 +00:00
Code Issues 1 Projects Releases Wiki Activity

moved asyncdisksrc to disksrc, no point in having a distinction

Browse source 
Original commit message from CVS:
moved asyncdisksrc to disksrc, no point in having a distinction
This commit is contained in:
Erik Walthinsen 2001-02-04 21:37:14 +00:00
parent c0ef1f3067
commit 38ff9ae802
12 changed files with 316 additions and 1154 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gst/elements/Makefile.am
View file

@ -15,7 +15,6 @@ libgstelements_la_SOURCES = \
gstidentity.c \ gstidentity.c \
gstfakesink.c \ gstfakesink.c \
gstdisksrc.c \ gstdisksrc.c \
gstasyncdisksrc.c \
gstfdsrc.c \ gstfdsrc.c \
gstaudiosink.c \ gstaudiosink.c \
gstaudiosrc.c \ gstaudiosrc.c \
@ -30,7 +29,6 @@ noinst_HEADERS = \
gstidentity.h \ gstidentity.h \
gstfakesink.h \ gstfakesink.h \
gstdisksrc.h \ gstdisksrc.h \
gstasyncdisksrc.h \
gstfdsrc.h \ gstfdsrc.h \
gsthttpsrc.h \ gsthttpsrc.h \
gstaudiosink.h \ gstaudiosink.h \

386
gst/elements/gstasyncdisksrc.c
View file

@ -1,386 +0,0 @@
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstasyncdisksrc.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 <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
//#define GST_DEBUG_ENABLED
#include "gstasyncdisksrc.h"
GstElementDetails gst_asyncdisksrc_details = {
"Asynchronous Disk Source",
"Source/File",
"Read from arbitrary point in a file",
VERSION,
"Erik Walthinsen <omega@cse.ogi.edu>",
"(C) 1999",
};
/* AsyncDiskSrc signals and args */
enum {
/* FILL ME */
LAST_SIGNAL
};
enum {
ARG_0,
ARG_LOCATION,
ARG_BYTESPERREAD,
ARG_OFFSET,
ARG_SIZE,
};
static void gst_asyncdisksrc_class_init (GstAsyncDiskSrcClass *klass);
static void gst_asyncdisksrc_init (GstAsyncDiskSrc *asyncdisksrc);
static void gst_asyncdisksrc_set_arg (GtkObject *object, GtkArg *arg, guint id);
static void gst_asyncdisksrc_get_arg (GtkObject *object, GtkArg *arg, guint id);
static GstBuffer * gst_asyncdisksrc_get (GstPad *pad);
static GstBuffer * gst_asyncdisksrc_get_region (GstPad *pad, gulong offset, gulong size);
static GstElementStateReturn gst_asyncdisksrc_change_state (GstElement *element);
static GstElementClass *parent_class = NULL;
//static guint gst_asyncdisksrc_signals[LAST_SIGNAL] = { 0 };
GtkType
gst_asyncdisksrc_get_type(void)
{
static GtkType asyncdisksrc_type = 0;
if (!asyncdisksrc_type) {
static const GtkTypeInfo asyncdisksrc_info = {
"GstAsyncDiskSrc",
sizeof(GstAsyncDiskSrc),
sizeof(GstAsyncDiskSrcClass),
(GtkClassInitFunc)gst_asyncdisksrc_class_init,
(GtkObjectInitFunc)gst_asyncdisksrc_init,
(GtkArgSetFunc)gst_asyncdisksrc_set_arg,
(GtkArgGetFunc)gst_asyncdisksrc_get_arg,
(GtkClassInitFunc)NULL,
};
asyncdisksrc_type = gtk_type_unique (GST_TYPE_ELEMENT, &asyncdisksrc_info);
}
return asyncdisksrc_type;
}
static void
gst_asyncdisksrc_class_init (GstAsyncDiskSrcClass *klass)
{
GtkObjectClass *gtkobject_class;
GstElementClass *gstelement_class;
gtkobject_class = (GtkObjectClass*)klass;
gstelement_class = (GstElementClass*)klass;
parent_class = gtk_type_class (GST_TYPE_ELEMENT);
gtk_object_add_arg_type ("GstAsyncDiskSrc::location", GST_TYPE_FILENAME,
GTK_ARG_READWRITE, ARG_LOCATION);
gtk_object_add_arg_type ("GstAsyncDiskSrc::bytesperread", GTK_TYPE_INT,
GTK_ARG_READWRITE, ARG_BYTESPERREAD);
gtk_object_add_arg_type ("GstAsyncDiskSrc::offset", GTK_TYPE_LONG,
GTK_ARG_READWRITE, ARG_OFFSET);
gtk_object_add_arg_type ("GstAsyncDiskSrc::size", GTK_TYPE_LONG,
GTK_ARG_READABLE, ARG_SIZE);
gtkobject_class->set_arg = gst_asyncdisksrc_set_arg;
gtkobject_class->get_arg = gst_asyncdisksrc_get_arg;
gstelement_class->change_state = gst_asyncdisksrc_change_state;
}
static void
gst_asyncdisksrc_init (GstAsyncDiskSrc *asyncdisksrc)
{
// GST_FLAG_SET (asyncdisksrc, GST_SRC_ASYNC);
asyncdisksrc->srcpad = gst_pad_new ("src", GST_PAD_SRC);
gst_pad_set_get_function (asyncdisksrc->srcpad,gst_asyncdisksrc_get);
gst_pad_set_getregion_function (asyncdisksrc->srcpad,gst_asyncdisksrc_get_region);
gst_element_add_pad (GST_ELEMENT (asyncdisksrc), asyncdisksrc->srcpad);
asyncdisksrc->filename = NULL;
asyncdisksrc->fd = 0;
asyncdisksrc->size = 0;
asyncdisksrc->map = NULL;
asyncdisksrc->curoffset = 0;
asyncdisksrc->bytes_per_read = 4096;
asyncdisksrc->seq = 0;
asyncdisksrc->new_seek = FALSE;
}
static void
gst_asyncdisksrc_set_arg (GtkObject *object, GtkArg *arg, guint id)
{
GstAsyncDiskSrc *src;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_ASYNCDISKSRC (object));
src = GST_ASYNCDISKSRC (object);
switch(id) {
case ARG_LOCATION:
/* the element must be stopped in order to do this */
g_return_if_fail (GST_STATE (src) < GST_STATE_PLAYING);
if (src->filename) g_free (src->filename);
/* clear the filename if we get a NULL (is that possible?) */
if (GTK_VALUE_STRING (*arg) == NULL) {
gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
src->filename = NULL;
/* otherwise set the new filename */
} else {
src->filename = g_strdup (GTK_VALUE_STRING (*arg));
}
break;
case ARG_BYTESPERREAD:
src->bytes_per_read = GTK_VALUE_INT (*arg);
break;
case ARG_OFFSET:
src->curoffset = GTK_VALUE_LONG (*arg);
src->new_seek = TRUE;
break;
default:
break;
}
}
static void
gst_asyncdisksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
{
GstAsyncDiskSrc *src;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_ASYNCDISKSRC (object));
src = GST_ASYNCDISKSRC (object);
switch (id) {
case ARG_LOCATION:
GTK_VALUE_STRING (*arg) = src->filename;
break;
case ARG_BYTESPERREAD:
GTK_VALUE_INT (*arg) = src->bytes_per_read;
break;
case ARG_OFFSET:
GTK_VALUE_LONG (*arg) = src->curoffset;
break;
case ARG_SIZE:
GTK_VALUE_LONG (*arg) = src->size;
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
/**
* gst_asyncdisksrc_get:
* @pad: #GstPad to push a buffer from
*
* Push a new buffer from the asyncdisksrc at the current offset.
*/
static GstBuffer *
gst_asyncdisksrc_get (GstPad *pad)
{
GstAsyncDiskSrc *src;
GstBuffer *buf;
g_return_val_if_fail (pad != NULL, NULL);
src = GST_ASYNCDISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_ASYNCDISKSRC_OPEN), NULL);
/* deal with EOF state */
if (src->curoffset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */
// FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new ();
g_return_val_if_fail (buf != NULL, NULL);
/* 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;
// FIXME: set the buffer's EOF bit here
} else
GST_BUFFER_SIZE (buf) = src->bytes_per_read;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, src->curoffset, GST_BUFFER_SIZE (buf));
//gst_util_dump_mem (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
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;
}
/* we're done, return the buffer */
return buf;
}
/**
* gst_asyncdisksrc_get_region:
* @src: #GstSrc to push a buffer from
* @offset: offset in file
* @size: number of bytes
*
* Push a new buffer from the asyncdisksrc of given size at given offset.
*/
static GstBuffer *
gst_asyncdisksrc_get_region (GstPad *pad, gulong offset, gulong size)
{
GstAsyncDiskSrc *src;
GstBuffer *buf;
g_return_val_if_fail (pad != NULL, NULL);
src = GST_ASYNCDISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_IS_ASYNCDISKSRC (src), NULL);
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_ASYNCDISKSRC_OPEN), NULL);
/* deal with EOF state */
if (offset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */
// FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new ();
g_return_val_if_fail (buf != NULL, NULL);
/* simply set the buffer to point to the correct region of the file */
GST_BUFFER_DATA (buf) = src->map + offset;
GST_BUFFER_OFFSET (buf) = offset;
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
if ((offset + size) > src->size) {
GST_BUFFER_SIZE (buf) = src->size - offset;
// FIXME: set the buffer's EOF bit here
} else
GST_BUFFER_SIZE (buf) = size;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, offset, GST_BUFFER_SIZE (buf));
/* we're done, return the buffer off now */
return buf;
}
/* open the file and mmap it, necessary to go to READY state */
static
gboolean gst_asyncdisksrc_open_file (GstAsyncDiskSrc *src)
{
g_return_val_if_fail (!GST_FLAG_IS_SET (src ,GST_ASYNCDISKSRC_OPEN), FALSE);
/* open the file */
src->fd = open (src->filename, O_RDONLY);
if (src->fd < 0) {
perror ("open");
gst_element_error (GST_ELEMENT (src), g_strconcat("opening file \"", src->filename, "\"", NULL));
return FALSE;
} else {
/* find the file length */
src->size = lseek (src->fd, 0, SEEK_END);
lseek (src->fd, 0, SEEK_SET);
/* map the file into memory */
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) {
close (src->fd);
gst_element_error (GST_ELEMENT (src),"mmapping file");
return FALSE;
}
GST_FLAG_SET (src, GST_ASYNCDISKSRC_OPEN);
src->new_seek = TRUE;
}
return TRUE;
}
/* unmap and close the file */
static void
gst_asyncdisksrc_close_file (GstAsyncDiskSrc *src)
{
g_return_if_fail (GST_FLAG_IS_SET (src, GST_ASYNCDISKSRC_OPEN));
/* unmap the file from memory */
munmap (src->map, src->size);
/* close the file */
close (src->fd);
/* zero out a lot of our state */
src->fd = 0;
src->size = 0;
src->map = NULL;
src->curoffset = 0;
src->seq = 0;
src->new_seek = FALSE;
GST_FLAG_UNSET (src, GST_ASYNCDISKSRC_OPEN);
}
static GstElementStateReturn
gst_asyncdisksrc_change_state (GstElement *element)
{
g_return_val_if_fail (GST_IS_ASYNCDISKSRC (element), GST_STATE_FAILURE);
if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
if (GST_FLAG_IS_SET (element, GST_ASYNCDISKSRC_OPEN))
gst_asyncdisksrc_close_file (GST_ASYNCDISKSRC (element));
} else {
if (!GST_FLAG_IS_SET (element, GST_ASYNCDISKSRC_OPEN)) {
if (!gst_asyncdisksrc_open_file (GST_ASYNCDISKSRC (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;
}

91
gst/elements/gstasyncdisksrc.h
View file

@ -1,91 +0,0 @@
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstasyncdisksrc.h:
*
* 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.
*/
#ifndef __GST_ASYNCDISKSRC_H__
#define __GST_ASYNCDISKSRC_H__
#include <gst/gst.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
GstElementDetails gst_asyncdisksrc_details;
#define GST_TYPE_ASYNCDISKSRC \
(gst_asyncdisksrc_get_type())
#define GST_ASYNCDISKSRC(obj) \
(GTK_CHECK_CAST((obj),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrc))
#define GST_ASYNCDISKSRC_CLASS(klass) \
(GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrcClass))
#define GST_IS_ASYNCDISKSRC(obj) \
(GTK_CHECK_TYPE((obj),GST_TYPE_ASYNCDISKSRC))
#define GST_IS_ASYNCDISKSRC_CLASS(obj) \
(GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ASYNCDISKSRC))
typedef enum {
GST_ASYNCDISKSRC_OPEN = GST_ELEMENT_FLAG_LAST,
GST_ASYNCDISKSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
} GstAsyncDiskSrcFlags;
typedef struct _GstAsyncDiskSrc GstAsyncDiskSrc;
typedef struct _GstAsyncDiskSrcClass GstAsyncDiskSrcClass;
struct _GstAsyncDiskSrc {
GstElement element;
/* pads */
GstPad *srcpad;
/* filename */
gchar *filename;
/* fd */
gint fd;
/* mapping parameters */
gulong size; /* how long is the file? */
guchar *map; /* where the file is mapped to */
/* details for fallback synchronous read */
gulong curoffset; /* current offset in file */
gulong bytes_per_read; /* bytes per read */
gboolean new_seek;
gulong seq; /* buffer sequence number */
};
struct _GstAsyncDiskSrcClass {
GstElementClass parent_class;
};
GtkType gst_asyncdisksrc_get_type(void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __GST_ASYNCDISKSRC_H__ */

216
gst/elements/gstdisksrc.c
View file

@ -24,14 +24,17 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include <sys/mman.h>
#include <gstdisksrc.h> //#define GST_DEBUG_ENABLED
#include "gstdisksrc.h"
GstElementDetails gst_disksrc_details = { GstElementDetails gst_disksrc_details = {
"Disk Source", "hronous Disk Source",
"Source/File", "Source/File",
"Synchronous read from a file", "Read from arbitrary point in a file",
VERSION, VERSION,
"Erik Walthinsen <omega@cse.ogi.edu>", "Erik Walthinsen <omega@cse.ogi.edu>",
"(C) 1999", "(C) 1999",
@ -53,15 +56,14 @@ enum {
}; };
static void gst_disksrc_class_init (GstDiskSrcClass *klass); static void gst_disksrc_class_init (GstDiskSrcClass *klass);
static void gst_disksrc_init (GstDiskSrc *disksrc); static void gst_disksrc_init (GstDiskSrc *disksrc);
static void gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id); static void gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id);
static void gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id); static void gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id);
static void gst_disksrc_close_file (GstDiskSrc *src); static GstBuffer * gst_disksrc_get (GstPad *pad);
static GstBuffer * gst_disksrc_get_region (GstPad *pad, gulong offset, gulong size);
static GstBuffer * gst_disksrc_get (GstPad *pad);
static GstElementStateReturn gst_disksrc_change_state (GstElement *element); static GstElementStateReturn gst_disksrc_change_state (GstElement *element);
@ -70,7 +72,8 @@ static GstElementClass *parent_class = NULL;
//static guint gst_disksrc_signals[LAST_SIGNAL] = { 0 }; //static guint gst_disksrc_signals[LAST_SIGNAL] = { 0 };
GtkType GtkType
gst_disksrc_get_type(void) { gst_disksrc_get_type(void)
{
static GtkType disksrc_type = 0; static GtkType disksrc_type = 0;
if (!disksrc_type) { if (!disksrc_type) {
@ -84,7 +87,7 @@ gst_disksrc_get_type(void) {
(GtkArgGetFunc)gst_disksrc_get_arg, (GtkArgGetFunc)gst_disksrc_get_arg,
(GtkClassInitFunc)NULL, (GtkClassInitFunc)NULL,
}; };
disksrc_type = gtk_type_unique(GST_TYPE_ELEMENT,&disksrc_info); disksrc_type = gtk_type_unique (GST_TYPE_ELEMENT, &disksrc_info);
} }
return disksrc_type; return disksrc_type;
} }
@ -104,9 +107,9 @@ gst_disksrc_class_init (GstDiskSrcClass *klass)
GTK_ARG_READWRITE, ARG_LOCATION); GTK_ARG_READWRITE, ARG_LOCATION);
gtk_object_add_arg_type ("GstDiskSrc::bytesperread", GTK_TYPE_INT, gtk_object_add_arg_type ("GstDiskSrc::bytesperread", GTK_TYPE_INT,
GTK_ARG_READWRITE, ARG_BYTESPERREAD); GTK_ARG_READWRITE, ARG_BYTESPERREAD);
gtk_object_add_arg_type ("GstDiskSrc::offset", GTK_TYPE_INT, gtk_object_add_arg_type ("GstDiskSrc::offset", GTK_TYPE_LONG,
GTK_ARG_READABLE, ARG_OFFSET); GTK_ARG_READWRITE, ARG_OFFSET);
gtk_object_add_arg_type ("GstDiskSrc::size", GTK_TYPE_INT, gtk_object_add_arg_type ("GstDiskSrc::size", GTK_TYPE_LONG,
GTK_ARG_READABLE, ARG_SIZE); GTK_ARG_READABLE, ARG_SIZE);
gtkobject_class->set_arg = gst_disksrc_set_arg; gtkobject_class->set_arg = gst_disksrc_set_arg;
@ -118,16 +121,20 @@ gst_disksrc_class_init (GstDiskSrcClass *klass)
static void static void
gst_disksrc_init (GstDiskSrc *disksrc) gst_disksrc_init (GstDiskSrc *disksrc)
{ {
// GST_FLAG_SET (disksrc, GST_SRC_);
disksrc->srcpad = gst_pad_new ("src", GST_PAD_SRC); disksrc->srcpad = gst_pad_new ("src", GST_PAD_SRC);
gst_pad_set_get_function(disksrc->srcpad,gst_disksrc_get); gst_pad_set_get_function (disksrc->srcpad,gst_disksrc_get);
gst_pad_set_getregion_function (disksrc->srcpad,gst_disksrc_get_region);
gst_element_add_pad (GST_ELEMENT (disksrc), disksrc->srcpad); gst_element_add_pad (GST_ELEMENT (disksrc), disksrc->srcpad);
disksrc->filename = NULL; disksrc->filename = NULL;
disksrc->fd = 0; disksrc->fd = 0;
disksrc->size = 0;
disksrc->map = NULL;
disksrc->curoffset = 0; disksrc->curoffset = 0;
disksrc->bytes_per_read = 4096; disksrc->bytes_per_read = 4096;
disksrc->seq = 0; disksrc->seq = 0;
disksrc->size = 0;
disksrc->new_seek = FALSE; disksrc->new_seek = FALSE;
} }
@ -144,8 +151,8 @@ gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id)
switch(id) { switch(id) {
case ARG_LOCATION: case ARG_LOCATION:
/* the element must not be playing in order to do this */ /* the element must be stopped in order to do this */
g_return_if_fail (GST_STATE(src) < GST_STATE_PLAYING); g_return_if_fail (GST_STATE (src) < GST_STATE_PLAYING);
if (src->filename) g_free (src->filename); if (src->filename) g_free (src->filename);
/* clear the filename if we get a NULL (is that possible?) */ /* clear the filename if we get a NULL (is that possible?) */
@ -160,13 +167,10 @@ gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id)
case ARG_BYTESPERREAD: case ARG_BYTESPERREAD:
src->bytes_per_read = GTK_VALUE_INT (*arg); src->bytes_per_read = GTK_VALUE_INT (*arg);
break; break;
/*
case ARG_OFFSET: case ARG_OFFSET:
src->curoffset = GTK_VALUE_INT(*arg); src->curoffset = GTK_VALUE_LONG (*arg);
lseek(src->fd,src->curoffset, SEEK_SET);
src->new_seek = TRUE; src->new_seek = TRUE;
break; break;
*/
default: default:
break; break;
} }
@ -179,6 +183,7 @@ gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
/* it's not null if we got it, but it might not be ours */ /* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_DISKSRC (object)); g_return_if_fail (GST_IS_DISKSRC (object));
src = GST_DISKSRC (object); src = GST_DISKSRC (object);
switch (id) { switch (id) {
@ -189,10 +194,10 @@ gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
GTK_VALUE_INT (*arg) = src->bytes_per_read; GTK_VALUE_INT (*arg) = src->bytes_per_read;
break; break;
case ARG_OFFSET: case ARG_OFFSET:
GTK_VALUE_INT (*arg) = src->curoffset; GTK_VALUE_LONG (*arg) = src->curoffset;
break; break;
case ARG_SIZE: case ARG_SIZE:
GTK_VALUE_INT (*arg) = src->size; GTK_VALUE_LONG (*arg) = src->size;
break; break;
default: default:
arg->type = GTK_TYPE_INVALID; arg->type = GTK_TYPE_INVALID;
@ -200,127 +205,180 @@ gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
} }
} }
/**
* gst_disksrc_get:
* @pad: #GstPad to push a buffer from
*
* Push a new buffer from the disksrc at the current offset.
*/
static GstBuffer * static GstBuffer *
gst_disksrc_get (GstPad *pad) gst_disksrc_get (GstPad *pad)
{ {
GstDiskSrc *src; GstDiskSrc *src;
GstBuffer *buf; GstBuffer *buf;
glong readbytes;
g_return_val_if_fail (pad != NULL, NULL); g_return_val_if_fail (pad != NULL, NULL);
src = GST_DISKSRC(gst_pad_get_parent (pad)); src = GST_DISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), NULL); g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), NULL);
g_return_val_if_fail (GST_STATE (src) >= GST_STATE_READY, NULL);
/* deal with EOF state */
if (src->curoffset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */ /* create the buffer */
// FIXME: should eventually use a bufferpool for this // FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new (); buf = gst_buffer_new ();
g_return_val_if_fail (buf, NULL);
/* allocate the space for the buffer data */ g_return_val_if_fail (buf != NULL, NULL);
GST_BUFFER_DATA (buf) = g_malloc (src->bytes_per_read);
g_return_val_if_fail (GST_BUFFER_DATA (buf) != NULL, NULL);
/* read it in from the file */ /* simply set the buffer to point to the correct region of the file */
readbytes = read (src->fd, GST_BUFFER_DATA (buf), src->bytes_per_read); GST_BUFFER_DATA (buf) = src->map + src->curoffset;
if (readbytes == -1) { GST_BUFFER_OFFSET (buf) = src->curoffset;
perror ("read()"); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
gst_buffer_unref (buf);
return NULL;
} else if (readbytes == 0) {
gst_element_signal_eos (GST_ELEMENT (src));
gst_buffer_unref (buf);
return NULL;
}
/* if we didn't get as many bytes as we asked for, we're at EOF */ if ((src->curoffset + src->bytes_per_read) > src->size) {
if (readbytes < src->bytes_per_read) { GST_BUFFER_SIZE (buf) = src->size - src->curoffset;
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_EOS); // FIXME: set the buffer's EOF bit here
GST_DEBUG (0,"setting GST_BUFFER_EOS\n"); } else
} GST_BUFFER_SIZE (buf) = src->bytes_per_read;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, src->curoffset, GST_BUFFER_SIZE (buf));
//gst_util_dump_mem (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
src->curoffset += GST_BUFFER_SIZE (buf);
/* if we have a new buffer from a seek, mark it */
if (src->new_seek) { if (src->new_seek) {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH);
GST_DEBUG (0,"new seek\n");
src->new_seek = FALSE; src->new_seek = FALSE;
} }
GST_BUFFER_OFFSET (buf) = src->curoffset; /* we're done, return the buffer */
GST_BUFFER_SIZE (buf) = readbytes; return buf;
src->curoffset += readbytes; }
GST_DEBUG (0,"pushing %d bytes with offset %d\n", GST_BUFFER_SIZE(buf), GST_BUFFER_OFFSET (buf)); /**
/* we're done, push the buffer off now */ * gst_disksrc_get_region:
GST_DEBUG (0,"returning %d bytes with offset %d done\n", GST_BUFFER_SIZE(buf), GST_BUFFER_OFFSET (buf)); * @src: #GstSrc to push a buffer from
* @offset: offset in file
* @size: number of bytes
*
* Push a new buffer from the disksrc of given size at given offset.
*/
static GstBuffer *
gst_disksrc_get_region (GstPad *pad, gulong offset, gulong size)
{
GstDiskSrc *src;
GstBuffer *buf;
g_return_val_if_fail (pad != NULL, NULL);
src = GST_DISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_IS_DISKSRC (src), NULL);
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), NULL);
/* deal with EOF state */
if (offset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */
// FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new ();
g_return_val_if_fail (buf != NULL, NULL);
/* simply set the buffer to point to the correct region of the file */
GST_BUFFER_DATA (buf) = src->map + offset;
GST_BUFFER_OFFSET (buf) = offset;
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
if ((offset + size) > src->size) {
GST_BUFFER_SIZE (buf) = src->size - offset;
// FIXME: set the buffer's EOF bit here
} else
GST_BUFFER_SIZE (buf) = size;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, offset, GST_BUFFER_SIZE (buf));
/* we're done, return the buffer off now */
return buf; return buf;
} }
/* open the file, necessary to go to RUNNING state */ /* open the file and mmap it, necessary to go to READY state */
static gboolean static
gst_disksrc_open_file (GstDiskSrc *src) gboolean gst_disksrc_open_file (GstDiskSrc *src)
{ {
struct stat f_stat; g_return_val_if_fail (!GST_FLAG_IS_SET (src ,GST_DISKSRC_OPEN), FALSE);
g_return_val_if_fail (!GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), FALSE);
g_return_val_if_fail (src->filename != NULL, FALSE);
/* open the file */ /* open the file */
src->fd = open (src->filename, O_RDONLY); src->fd = open (src->filename, O_RDONLY);
if (src->fd < 0) { if (src->fd < 0) {
perror ("open()"); perror ("open");
gst_element_error (GST_ELEMENT (src), "opening file"); gst_element_error (GST_ELEMENT (src), g_strconcat("opening file \"", src->filename, "\"", NULL));
return FALSE; return FALSE;
} else {
/* find the file length */
src->size = lseek (src->fd, 0, SEEK_END);
lseek (src->fd, 0, SEEK_SET);
/* map the file into memory */
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) {
close (src->fd);
gst_element_error (GST_ELEMENT (src),"mmapping file");
return FALSE;
}
GST_FLAG_SET (src, GST_DISKSRC_OPEN);
src->new_seek = TRUE;
} }
if (fstat (src->fd, &f_stat) < 0) {
perror("fstat()");
}
else {
src->size = f_stat.st_size;
GST_DEBUG (0,"gstdisksrc: file size %ld\n", src->size);
}
GST_FLAG_SET (src, GST_DISKSRC_OPEN);
return TRUE; return TRUE;
} }
/* close the file */ /* unmap and close the file */
static void static void
gst_disksrc_close_file (GstDiskSrc *src) gst_disksrc_close_file (GstDiskSrc *src)
{ {
g_return_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN)); g_return_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN));
/* unmap the file from memory */
munmap (src->map, src->size);
/* close the file */ /* close the file */
close (src->fd); close (src->fd);
/* zero out a lot of our state */ /* zero out a lot of our state */
src->fd = 0; src->fd = 0;
src->size = 0;
src->map = NULL;
src->curoffset = 0; src->curoffset = 0;
src->seq = 0; src->seq = 0;
src->size = 0; src->new_seek = FALSE;
GST_FLAG_UNSET (src, GST_DISKSRC_OPEN); GST_FLAG_UNSET (src, GST_DISKSRC_OPEN);
} }
static GstElementStateReturn static GstElementStateReturn
gst_disksrc_change_state (GstElement *element) gst_disksrc_change_state (GstElement *element)
{ {
g_return_val_if_fail (GST_IS_DISKSRC (element), GST_STATE_FAILURE); g_return_val_if_fail (GST_IS_DISKSRC (element), GST_STATE_FAILURE);
GST_DEBUG (0,"gstdisksrc: state pending %d\n", GST_STATE_PENDING (element));
/* if going down into NULL state, close the file if it's open */
if (GST_STATE_PENDING (element) == GST_STATE_NULL) { if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
if (GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN)) if (GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN))
gst_disksrc_close_file (GST_DISKSRC (element)); gst_disksrc_close_file (GST_DISKSRC (element));
/* otherwise (READY or higher) we need to open the file */
} else { } else {
if (!GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN)) { if (!GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN)) {
if (!gst_disksrc_open_file (GST_DISKSRC (element))) if (!gst_disksrc_open_file (GST_DISKSRC (element)))
return GST_STATE_FAILURE; return GST_STATE_FAILURE;
} }
} }
/* if we haven't failed already, give the parent class a chance to ;-) */
if (GST_ELEMENT_CLASS (parent_class)->change_state) if (GST_ELEMENT_CLASS (parent_class)->change_state)
return GST_ELEMENT_CLASS (parent_class)->change_state (element); return GST_ELEMENT_CLASS (parent_class)->change_state (element);

15
gst/elements/gstdisksrc.h
View file

@ -25,7 +25,6 @@
#define __GST_DISKSRC_H__ #define __GST_DISKSRC_H__
#include <config.h>
#include <gst/gst.h> #include <gst/gst.h>
@ -34,8 +33,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
extern GstElementDetails gst_disksrc_details; GstElementDetails gst_disksrc_details;
#define GST_TYPE_DISKSRC \ #define GST_TYPE_DISKSRC \
(gst_disksrc_get_type()) (gst_disksrc_get_type())
@ -51,7 +49,7 @@ extern GstElementDetails gst_disksrc_details;
typedef enum { typedef enum {
GST_DISKSRC_OPEN = GST_ELEMENT_FLAG_LAST, GST_DISKSRC_OPEN = GST_ELEMENT_FLAG_LAST,
GST_DISKSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST+2, GST_DISKSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
} GstDiskSrcFlags; } GstDiskSrcFlags;
typedef struct _GstDiskSrc GstDiskSrc; typedef struct _GstDiskSrc GstDiskSrc;
@ -62,16 +60,21 @@ struct _GstDiskSrc {
/* pads */ /* pads */
GstPad *srcpad; GstPad *srcpad;
/* file state */ /* filename */
gchar *filename; gchar *filename;
/* fd */
gint fd; gint fd;
/* mapping parameters */
gulong size; /* how long is the file? */
guchar *map; /* where the file is mapped to */
/* details for fallback synchronous read */
gulong curoffset; /* current offset in file */ gulong curoffset; /* current offset in file */
gulong bytes_per_read; /* bytes per read */ gulong bytes_per_read; /* bytes per read */
gboolean new_seek; gboolean new_seek;
gulong seq; /* buffer sequence number */ gulong seq; /* buffer sequence number */
gulong size;
}; };
struct _GstDiskSrcClass { struct _GstDiskSrcClass {

25
gst/elements/gstelements.c
View file

@ -23,7 +23,6 @@
#include <gst/gst.h> #include <gst/gst.h>
#include "gstasyncdisksrc.h"
#include "gstaudiosink.h" #include "gstaudiosink.h"
#include "gstaudiosrc.h" #include "gstaudiosrc.h"
#include "gstdisksrc.h" #include "gstdisksrc.h"
@ -49,18 +48,18 @@ struct _elements_entry {
}; };
static struct _elements_entry _elements[] = { static struct _elements_entry _elements[] = {
{ "fakesrc", gst_fakesrc_get_type, &gst_fakesrc_details, NULL }, { "fakesrc", gst_fakesrc_get_type, &gst_fakesrc_details, NULL },
{ "fakesink", gst_fakesink_get_type, &gst_fakesink_details, NULL }, { "fakesink", gst_fakesink_get_type, &gst_fakesink_details, NULL },
{ "asyncdisksrc", gst_asyncdisksrc_get_type, &gst_asyncdisksrc_details, NULL }, { "asyncdisksrc", gst_disksrc_get_type, &gst_disksrc_details, NULL },
{ "audiosink", gst_audiosink_get_type, &gst_audiosink_details, gst_audiosink_factory_init }, { "audiosink", gst_audiosink_get_type, &gst_audiosink_details, gst_audiosink_factory_init },
{ "audiosrc", gst_audiosrc_get_type, &gst_audiosrc_details, NULL }, { "audiosrc", gst_audiosrc_get_type, &gst_audiosrc_details, NULL },
{ "disksrc", gst_disksrc_get_type, &gst_disksrc_details, NULL }, { "disksrc", gst_disksrc_get_type, &gst_disksrc_details, NULL },
{ "identity", gst_identity_get_type, &gst_identity_details, NULL }, { "identity", gst_identity_get_type, &gst_identity_details, NULL },
{ "fdsink", gst_fdsink_get_type, &gst_fdsink_details, NULL }, { "fdsink", gst_fdsink_get_type, &gst_fdsink_details, NULL },
{ "fdsrc", gst_fdsrc_get_type, &gst_fdsrc_details, NULL }, { "fdsrc", gst_fdsrc_get_type, &gst_fdsrc_details, NULL },
{ "pipefilter", gst_pipefilter_get_type, &gst_pipefilter_details, NULL }, { "pipefilter", gst_pipefilter_get_type, &gst_pipefilter_details, NULL },
{ "sinesrc", gst_sinesrc_get_type, &gst_sinesrc_details, NULL }, { "sinesrc", gst_sinesrc_get_type, &gst_sinesrc_details, NULL },
{ "tee", gst_tee_get_type, &gst_tee_details, gst_tee_factory_init }, { "tee", gst_tee_get_type, &gst_tee_details, gst_tee_factory_init },
#if HAVE_LIBGHTTP #if HAVE_LIBGHTTP
{ "httpsrc", gst_httpsrc_get_type, &gst_httpsrc_details, NULL }, { "httpsrc", gst_httpsrc_get_type, &gst_httpsrc_details, NULL },

2
plugins/elements/Makefile.am
View file

@ -15,7 +15,6 @@ libgstelements_la_SOURCES = \
gstidentity.c \ gstidentity.c \
gstfakesink.c \ gstfakesink.c \
gstdisksrc.c \ gstdisksrc.c \
gstasyncdisksrc.c \
gstfdsrc.c \ gstfdsrc.c \
gstaudiosink.c \ gstaudiosink.c \
gstaudiosrc.c \ gstaudiosrc.c \
@ -30,7 +29,6 @@ noinst_HEADERS = \
gstidentity.h \ gstidentity.h \
gstfakesink.h \ gstfakesink.h \
gstdisksrc.h \ gstdisksrc.h \
gstasyncdisksrc.h \
gstfdsrc.h \ gstfdsrc.h \
gsthttpsrc.h \ gsthttpsrc.h \
gstaudiosink.h \ gstaudiosink.h \

386
plugins/elements/gstasyncdisksrc.c
View file

@ -1,386 +0,0 @@
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstasyncdisksrc.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 <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
//#define GST_DEBUG_ENABLED
#include "gstasyncdisksrc.h"
GstElementDetails gst_asyncdisksrc_details = {
"Asynchronous Disk Source",
"Source/File",
"Read from arbitrary point in a file",
VERSION,
"Erik Walthinsen <omega@cse.ogi.edu>",
"(C) 1999",
};
/* AsyncDiskSrc signals and args */
enum {
/* FILL ME */
LAST_SIGNAL
};
enum {
ARG_0,
ARG_LOCATION,
ARG_BYTESPERREAD,
ARG_OFFSET,
ARG_SIZE,
};
static void gst_asyncdisksrc_class_init (GstAsyncDiskSrcClass *klass);
static void gst_asyncdisksrc_init (GstAsyncDiskSrc *asyncdisksrc);
static void gst_asyncdisksrc_set_arg (GtkObject *object, GtkArg *arg, guint id);
static void gst_asyncdisksrc_get_arg (GtkObject *object, GtkArg *arg, guint id);
static GstBuffer * gst_asyncdisksrc_get (GstPad *pad);
static GstBuffer * gst_asyncdisksrc_get_region (GstPad *pad, gulong offset, gulong size);
static GstElementStateReturn gst_asyncdisksrc_change_state (GstElement *element);
static GstElementClass *parent_class = NULL;
//static guint gst_asyncdisksrc_signals[LAST_SIGNAL] = { 0 };
GtkType
gst_asyncdisksrc_get_type(void)
{
static GtkType asyncdisksrc_type = 0;
if (!asyncdisksrc_type) {
static const GtkTypeInfo asyncdisksrc_info = {
"GstAsyncDiskSrc",
sizeof(GstAsyncDiskSrc),
sizeof(GstAsyncDiskSrcClass),
(GtkClassInitFunc)gst_asyncdisksrc_class_init,
(GtkObjectInitFunc)gst_asyncdisksrc_init,
(GtkArgSetFunc)gst_asyncdisksrc_set_arg,
(GtkArgGetFunc)gst_asyncdisksrc_get_arg,
(GtkClassInitFunc)NULL,
};
asyncdisksrc_type = gtk_type_unique (GST_TYPE_ELEMENT, &asyncdisksrc_info);
}
return asyncdisksrc_type;
}
static void
gst_asyncdisksrc_class_init (GstAsyncDiskSrcClass *klass)
{
GtkObjectClass *gtkobject_class;
GstElementClass *gstelement_class;
gtkobject_class = (GtkObjectClass*)klass;
gstelement_class = (GstElementClass*)klass;
parent_class = gtk_type_class (GST_TYPE_ELEMENT);
gtk_object_add_arg_type ("GstAsyncDiskSrc::location", GST_TYPE_FILENAME,
GTK_ARG_READWRITE, ARG_LOCATION);
gtk_object_add_arg_type ("GstAsyncDiskSrc::bytesperread", GTK_TYPE_INT,
GTK_ARG_READWRITE, ARG_BYTESPERREAD);
gtk_object_add_arg_type ("GstAsyncDiskSrc::offset", GTK_TYPE_LONG,
GTK_ARG_READWRITE, ARG_OFFSET);
gtk_object_add_arg_type ("GstAsyncDiskSrc::size", GTK_TYPE_LONG,
GTK_ARG_READABLE, ARG_SIZE);
gtkobject_class->set_arg = gst_asyncdisksrc_set_arg;
gtkobject_class->get_arg = gst_asyncdisksrc_get_arg;
gstelement_class->change_state = gst_asyncdisksrc_change_state;
}
static void
gst_asyncdisksrc_init (GstAsyncDiskSrc *asyncdisksrc)
{
// GST_FLAG_SET (asyncdisksrc, GST_SRC_ASYNC);
asyncdisksrc->srcpad = gst_pad_new ("src", GST_PAD_SRC);
gst_pad_set_get_function (asyncdisksrc->srcpad,gst_asyncdisksrc_get);
gst_pad_set_getregion_function (asyncdisksrc->srcpad,gst_asyncdisksrc_get_region);
gst_element_add_pad (GST_ELEMENT (asyncdisksrc), asyncdisksrc->srcpad);
asyncdisksrc->filename = NULL;
asyncdisksrc->fd = 0;
asyncdisksrc->size = 0;
asyncdisksrc->map = NULL;
asyncdisksrc->curoffset = 0;
asyncdisksrc->bytes_per_read = 4096;
asyncdisksrc->seq = 0;
asyncdisksrc->new_seek = FALSE;
}
static void
gst_asyncdisksrc_set_arg (GtkObject *object, GtkArg *arg, guint id)
{
GstAsyncDiskSrc *src;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_ASYNCDISKSRC (object));
src = GST_ASYNCDISKSRC (object);
switch(id) {
case ARG_LOCATION:
/* the element must be stopped in order to do this */
g_return_if_fail (GST_STATE (src) < GST_STATE_PLAYING);
if (src->filename) g_free (src->filename);
/* clear the filename if we get a NULL (is that possible?) */
if (GTK_VALUE_STRING (*arg) == NULL) {
gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
src->filename = NULL;
/* otherwise set the new filename */
} else {
src->filename = g_strdup (GTK_VALUE_STRING (*arg));
}
break;
case ARG_BYTESPERREAD:
src->bytes_per_read = GTK_VALUE_INT (*arg);
break;
case ARG_OFFSET:
src->curoffset = GTK_VALUE_LONG (*arg);
src->new_seek = TRUE;
break;
default:
break;
}
}
static void
gst_asyncdisksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
{
GstAsyncDiskSrc *src;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_ASYNCDISKSRC (object));
src = GST_ASYNCDISKSRC (object);
switch (id) {
case ARG_LOCATION:
GTK_VALUE_STRING (*arg) = src->filename;
break;
case ARG_BYTESPERREAD:
GTK_VALUE_INT (*arg) = src->bytes_per_read;
break;
case ARG_OFFSET:
GTK_VALUE_LONG (*arg) = src->curoffset;
break;
case ARG_SIZE:
GTK_VALUE_LONG (*arg) = src->size;
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
/**
* gst_asyncdisksrc_get:
* @pad: #GstPad to push a buffer from
*
* Push a new buffer from the asyncdisksrc at the current offset.
*/
static GstBuffer *
gst_asyncdisksrc_get (GstPad *pad)
{
GstAsyncDiskSrc *src;
GstBuffer *buf;
g_return_val_if_fail (pad != NULL, NULL);
src = GST_ASYNCDISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_ASYNCDISKSRC_OPEN), NULL);
/* deal with EOF state */
if (src->curoffset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */
// FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new ();
g_return_val_if_fail (buf != NULL, NULL);
/* 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;
// FIXME: set the buffer's EOF bit here
} else
GST_BUFFER_SIZE (buf) = src->bytes_per_read;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, src->curoffset, GST_BUFFER_SIZE (buf));
//gst_util_dump_mem (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
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;
}
/* we're done, return the buffer */
return buf;
}
/**
* gst_asyncdisksrc_get_region:
* @src: #GstSrc to push a buffer from
* @offset: offset in file
* @size: number of bytes
*
* Push a new buffer from the asyncdisksrc of given size at given offset.
*/
static GstBuffer *
gst_asyncdisksrc_get_region (GstPad *pad, gulong offset, gulong size)
{
GstAsyncDiskSrc *src;
GstBuffer *buf;
g_return_val_if_fail (pad != NULL, NULL);
src = GST_ASYNCDISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_IS_ASYNCDISKSRC (src), NULL);
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_ASYNCDISKSRC_OPEN), NULL);
/* deal with EOF state */
if (offset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */
// FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new ();
g_return_val_if_fail (buf != NULL, NULL);
/* simply set the buffer to point to the correct region of the file */
GST_BUFFER_DATA (buf) = src->map + offset;
GST_BUFFER_OFFSET (buf) = offset;
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
if ((offset + size) > src->size) {
GST_BUFFER_SIZE (buf) = src->size - offset;
// FIXME: set the buffer's EOF bit here
} else
GST_BUFFER_SIZE (buf) = size;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, offset, GST_BUFFER_SIZE (buf));
/* we're done, return the buffer off now */
return buf;
}
/* open the file and mmap it, necessary to go to READY state */
static
gboolean gst_asyncdisksrc_open_file (GstAsyncDiskSrc *src)
{
g_return_val_if_fail (!GST_FLAG_IS_SET (src ,GST_ASYNCDISKSRC_OPEN), FALSE);
/* open the file */
src->fd = open (src->filename, O_RDONLY);
if (src->fd < 0) {
perror ("open");
gst_element_error (GST_ELEMENT (src), g_strconcat("opening file \"", src->filename, "\"", NULL));
return FALSE;
} else {
/* find the file length */
src->size = lseek (src->fd, 0, SEEK_END);
lseek (src->fd, 0, SEEK_SET);
/* map the file into memory */
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) {
close (src->fd);
gst_element_error (GST_ELEMENT (src),"mmapping file");
return FALSE;
}
GST_FLAG_SET (src, GST_ASYNCDISKSRC_OPEN);
src->new_seek = TRUE;
}
return TRUE;
}
/* unmap and close the file */
static void
gst_asyncdisksrc_close_file (GstAsyncDiskSrc *src)
{
g_return_if_fail (GST_FLAG_IS_SET (src, GST_ASYNCDISKSRC_OPEN));
/* unmap the file from memory */
munmap (src->map, src->size);
/* close the file */
close (src->fd);
/* zero out a lot of our state */
src->fd = 0;
src->size = 0;
src->map = NULL;
src->curoffset = 0;
src->seq = 0;
src->new_seek = FALSE;
GST_FLAG_UNSET (src, GST_ASYNCDISKSRC_OPEN);
}
static GstElementStateReturn
gst_asyncdisksrc_change_state (GstElement *element)
{
g_return_val_if_fail (GST_IS_ASYNCDISKSRC (element), GST_STATE_FAILURE);
if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
if (GST_FLAG_IS_SET (element, GST_ASYNCDISKSRC_OPEN))
gst_asyncdisksrc_close_file (GST_ASYNCDISKSRC (element));
} else {
if (!GST_FLAG_IS_SET (element, GST_ASYNCDISKSRC_OPEN)) {
if (!gst_asyncdisksrc_open_file (GST_ASYNCDISKSRC (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;
}

91
plugins/elements/gstasyncdisksrc.h
View file

@ -1,91 +0,0 @@
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstasyncdisksrc.h:
*
* 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.
*/
#ifndef __GST_ASYNCDISKSRC_H__
#define __GST_ASYNCDISKSRC_H__
#include <gst/gst.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
GstElementDetails gst_asyncdisksrc_details;
#define GST_TYPE_ASYNCDISKSRC \
(gst_asyncdisksrc_get_type())
#define GST_ASYNCDISKSRC(obj) \
(GTK_CHECK_CAST((obj),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrc))
#define GST_ASYNCDISKSRC_CLASS(klass) \
(GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrcClass))
#define GST_IS_ASYNCDISKSRC(obj) \
(GTK_CHECK_TYPE((obj),GST_TYPE_ASYNCDISKSRC))
#define GST_IS_ASYNCDISKSRC_CLASS(obj) \
(GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ASYNCDISKSRC))
typedef enum {
GST_ASYNCDISKSRC_OPEN = GST_ELEMENT_FLAG_LAST,
GST_ASYNCDISKSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
} GstAsyncDiskSrcFlags;
typedef struct _GstAsyncDiskSrc GstAsyncDiskSrc;
typedef struct _GstAsyncDiskSrcClass GstAsyncDiskSrcClass;
struct _GstAsyncDiskSrc {
GstElement element;
/* pads */
GstPad *srcpad;
/* filename */
gchar *filename;
/* fd */
gint fd;
/* mapping parameters */
gulong size; /* how long is the file? */
guchar *map; /* where the file is mapped to */
/* details for fallback synchronous read */
gulong curoffset; /* current offset in file */
gulong bytes_per_read; /* bytes per read */
gboolean new_seek;
gulong seq; /* buffer sequence number */
};
struct _GstAsyncDiskSrcClass {
GstElementClass parent_class;
};
GtkType gst_asyncdisksrc_get_type(void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __GST_ASYNCDISKSRC_H__ */

216
plugins/elements/gstdisksrc.c
View file

@ -24,14 +24,17 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include <sys/mman.h>
#include <gstdisksrc.h> //#define GST_DEBUG_ENABLED
#include "gstdisksrc.h"
GstElementDetails gst_disksrc_details = { GstElementDetails gst_disksrc_details = {
"Disk Source", "hronous Disk Source",
"Source/File", "Source/File",
"Synchronous read from a file", "Read from arbitrary point in a file",
VERSION, VERSION,
"Erik Walthinsen <omega@cse.ogi.edu>", "Erik Walthinsen <omega@cse.ogi.edu>",
"(C) 1999", "(C) 1999",
@ -53,15 +56,14 @@ enum {
}; };
static void gst_disksrc_class_init (GstDiskSrcClass *klass); static void gst_disksrc_class_init (GstDiskSrcClass *klass);
static void gst_disksrc_init (GstDiskSrc *disksrc); static void gst_disksrc_init (GstDiskSrc *disksrc);
static void gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id); static void gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id);
static void gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id); static void gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id);
static void gst_disksrc_close_file (GstDiskSrc *src); static GstBuffer * gst_disksrc_get (GstPad *pad);
static GstBuffer * gst_disksrc_get_region (GstPad *pad, gulong offset, gulong size);
static GstBuffer * gst_disksrc_get (GstPad *pad);
static GstElementStateReturn gst_disksrc_change_state (GstElement *element); static GstElementStateReturn gst_disksrc_change_state (GstElement *element);
@ -70,7 +72,8 @@ static GstElementClass *parent_class = NULL;
//static guint gst_disksrc_signals[LAST_SIGNAL] = { 0 }; //static guint gst_disksrc_signals[LAST_SIGNAL] = { 0 };
GtkType GtkType
gst_disksrc_get_type(void) { gst_disksrc_get_type(void)
{
static GtkType disksrc_type = 0; static GtkType disksrc_type = 0;
if (!disksrc_type) { if (!disksrc_type) {
@ -84,7 +87,7 @@ gst_disksrc_get_type(void) {
(GtkArgGetFunc)gst_disksrc_get_arg, (GtkArgGetFunc)gst_disksrc_get_arg,
(GtkClassInitFunc)NULL, (GtkClassInitFunc)NULL,
}; };
disksrc_type = gtk_type_unique(GST_TYPE_ELEMENT,&disksrc_info); disksrc_type = gtk_type_unique (GST_TYPE_ELEMENT, &disksrc_info);
} }
return disksrc_type; return disksrc_type;
} }
@ -104,9 +107,9 @@ gst_disksrc_class_init (GstDiskSrcClass *klass)
GTK_ARG_READWRITE, ARG_LOCATION); GTK_ARG_READWRITE, ARG_LOCATION);
gtk_object_add_arg_type ("GstDiskSrc::bytesperread", GTK_TYPE_INT, gtk_object_add_arg_type ("GstDiskSrc::bytesperread", GTK_TYPE_INT,
GTK_ARG_READWRITE, ARG_BYTESPERREAD); GTK_ARG_READWRITE, ARG_BYTESPERREAD);
gtk_object_add_arg_type ("GstDiskSrc::offset", GTK_TYPE_INT, gtk_object_add_arg_type ("GstDiskSrc::offset", GTK_TYPE_LONG,
GTK_ARG_READABLE, ARG_OFFSET); GTK_ARG_READWRITE, ARG_OFFSET);
gtk_object_add_arg_type ("GstDiskSrc::size", GTK_TYPE_INT, gtk_object_add_arg_type ("GstDiskSrc::size", GTK_TYPE_LONG,
GTK_ARG_READABLE, ARG_SIZE); GTK_ARG_READABLE, ARG_SIZE);
gtkobject_class->set_arg = gst_disksrc_set_arg; gtkobject_class->set_arg = gst_disksrc_set_arg;
@ -118,16 +121,20 @@ gst_disksrc_class_init (GstDiskSrcClass *klass)
static void static void
gst_disksrc_init (GstDiskSrc *disksrc) gst_disksrc_init (GstDiskSrc *disksrc)
{ {
// GST_FLAG_SET (disksrc, GST_SRC_);
disksrc->srcpad = gst_pad_new ("src", GST_PAD_SRC); disksrc->srcpad = gst_pad_new ("src", GST_PAD_SRC);
gst_pad_set_get_function(disksrc->srcpad,gst_disksrc_get); gst_pad_set_get_function (disksrc->srcpad,gst_disksrc_get);
gst_pad_set_getregion_function (disksrc->srcpad,gst_disksrc_get_region);
gst_element_add_pad (GST_ELEMENT (disksrc), disksrc->srcpad); gst_element_add_pad (GST_ELEMENT (disksrc), disksrc->srcpad);
disksrc->filename = NULL; disksrc->filename = NULL;
disksrc->fd = 0; disksrc->fd = 0;
disksrc->size = 0;
disksrc->map = NULL;
disksrc->curoffset = 0; disksrc->curoffset = 0;
disksrc->bytes_per_read = 4096; disksrc->bytes_per_read = 4096;
disksrc->seq = 0; disksrc->seq = 0;
disksrc->size = 0;
disksrc->new_seek = FALSE; disksrc->new_seek = FALSE;
} }
@ -144,8 +151,8 @@ gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id)
switch(id) { switch(id) {
case ARG_LOCATION: case ARG_LOCATION:
/* the element must not be playing in order to do this */ /* the element must be stopped in order to do this */
g_return_if_fail (GST_STATE(src) < GST_STATE_PLAYING); g_return_if_fail (GST_STATE (src) < GST_STATE_PLAYING);
if (src->filename) g_free (src->filename); if (src->filename) g_free (src->filename);
/* clear the filename if we get a NULL (is that possible?) */ /* clear the filename if we get a NULL (is that possible?) */
@ -160,13 +167,10 @@ gst_disksrc_set_arg (GtkObject *object, GtkArg *arg, guint id)
case ARG_BYTESPERREAD: case ARG_BYTESPERREAD:
src->bytes_per_read = GTK_VALUE_INT (*arg); src->bytes_per_read = GTK_VALUE_INT (*arg);
break; break;
/*
case ARG_OFFSET: case ARG_OFFSET:
src->curoffset = GTK_VALUE_INT(*arg); src->curoffset = GTK_VALUE_LONG (*arg);
lseek(src->fd,src->curoffset, SEEK_SET);
src->new_seek = TRUE; src->new_seek = TRUE;
break; break;
*/
default: default:
break; break;
} }
@ -179,6 +183,7 @@ gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
/* it's not null if we got it, but it might not be ours */ /* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_DISKSRC (object)); g_return_if_fail (GST_IS_DISKSRC (object));
src = GST_DISKSRC (object); src = GST_DISKSRC (object);
switch (id) { switch (id) {
@ -189,10 +194,10 @@ gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
GTK_VALUE_INT (*arg) = src->bytes_per_read; GTK_VALUE_INT (*arg) = src->bytes_per_read;
break; break;
case ARG_OFFSET: case ARG_OFFSET:
GTK_VALUE_INT (*arg) = src->curoffset; GTK_VALUE_LONG (*arg) = src->curoffset;
break; break;
case ARG_SIZE: case ARG_SIZE:
GTK_VALUE_INT (*arg) = src->size; GTK_VALUE_LONG (*arg) = src->size;
break; break;
default: default:
arg->type = GTK_TYPE_INVALID; arg->type = GTK_TYPE_INVALID;
@ -200,127 +205,180 @@ gst_disksrc_get_arg (GtkObject *object, GtkArg *arg, guint id)
} }
} }
/**
* gst_disksrc_get:
* @pad: #GstPad to push a buffer from
*
* Push a new buffer from the disksrc at the current offset.
*/
static GstBuffer * static GstBuffer *
gst_disksrc_get (GstPad *pad) gst_disksrc_get (GstPad *pad)
{ {
GstDiskSrc *src; GstDiskSrc *src;
GstBuffer *buf; GstBuffer *buf;
glong readbytes;
g_return_val_if_fail (pad != NULL, NULL); g_return_val_if_fail (pad != NULL, NULL);
src = GST_DISKSRC(gst_pad_get_parent (pad)); src = GST_DISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), NULL); g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), NULL);
g_return_val_if_fail (GST_STATE (src) >= GST_STATE_READY, NULL);
/* deal with EOF state */
if (src->curoffset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */ /* create the buffer */
// FIXME: should eventually use a bufferpool for this // FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new (); buf = gst_buffer_new ();
g_return_val_if_fail (buf, NULL);
/* allocate the space for the buffer data */ g_return_val_if_fail (buf != NULL, NULL);
GST_BUFFER_DATA (buf) = g_malloc (src->bytes_per_read);
g_return_val_if_fail (GST_BUFFER_DATA (buf) != NULL, NULL);
/* read it in from the file */ /* simply set the buffer to point to the correct region of the file */
readbytes = read (src->fd, GST_BUFFER_DATA (buf), src->bytes_per_read); GST_BUFFER_DATA (buf) = src->map + src->curoffset;
if (readbytes == -1) { GST_BUFFER_OFFSET (buf) = src->curoffset;
perror ("read()"); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
gst_buffer_unref (buf);
return NULL;
} else if (readbytes == 0) {
gst_element_signal_eos (GST_ELEMENT (src));
gst_buffer_unref (buf);
return NULL;
}
/* if we didn't get as many bytes as we asked for, we're at EOF */ if ((src->curoffset + src->bytes_per_read) > src->size) {
if (readbytes < src->bytes_per_read) { GST_BUFFER_SIZE (buf) = src->size - src->curoffset;
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_EOS); // FIXME: set the buffer's EOF bit here
GST_DEBUG (0,"setting GST_BUFFER_EOS\n"); } else
} GST_BUFFER_SIZE (buf) = src->bytes_per_read;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, src->curoffset, GST_BUFFER_SIZE (buf));
//gst_util_dump_mem (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
src->curoffset += GST_BUFFER_SIZE (buf);
/* if we have a new buffer from a seek, mark it */
if (src->new_seek) { if (src->new_seek) {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH);
GST_DEBUG (0,"new seek\n");
src->new_seek = FALSE; src->new_seek = FALSE;
} }
GST_BUFFER_OFFSET (buf) = src->curoffset; /* we're done, return the buffer */
GST_BUFFER_SIZE (buf) = readbytes; return buf;
src->curoffset += readbytes; }
GST_DEBUG (0,"pushing %d bytes with offset %d\n", GST_BUFFER_SIZE(buf), GST_BUFFER_OFFSET (buf)); /**
/* we're done, push the buffer off now */ * gst_disksrc_get_region:
GST_DEBUG (0,"returning %d bytes with offset %d done\n", GST_BUFFER_SIZE(buf), GST_BUFFER_OFFSET (buf)); * @src: #GstSrc to push a buffer from
* @offset: offset in file
* @size: number of bytes
*
* Push a new buffer from the disksrc of given size at given offset.
*/
static GstBuffer *
gst_disksrc_get_region (GstPad *pad, gulong offset, gulong size)
{
GstDiskSrc *src;
GstBuffer *buf;
g_return_val_if_fail (pad != NULL, NULL);
src = GST_DISKSRC (gst_pad_get_parent (pad));
g_return_val_if_fail (GST_IS_DISKSRC (src), NULL);
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), NULL);
/* deal with EOF state */
if (offset >= src->size) {
gst_element_signal_eos (GST_ELEMENT (src));
return NULL;
}
/* create the buffer */
// FIXME: should eventually use a bufferpool for this
buf = gst_buffer_new ();
g_return_val_if_fail (buf != NULL, NULL);
/* simply set the buffer to point to the correct region of the file */
GST_BUFFER_DATA (buf) = src->map + offset;
GST_BUFFER_OFFSET (buf) = offset;
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
if ((offset + size) > src->size) {
GST_BUFFER_SIZE (buf) = src->size - offset;
// FIXME: set the buffer's EOF bit here
} else
GST_BUFFER_SIZE (buf) = size;
GST_DEBUG (0,"map %p, offset %ld, size %d\n", src->map, offset, GST_BUFFER_SIZE (buf));
/* we're done, return the buffer off now */
return buf; return buf;
} }
/* open the file, necessary to go to RUNNING state */ /* open the file and mmap it, necessary to go to READY state */
static gboolean static
gst_disksrc_open_file (GstDiskSrc *src) gboolean gst_disksrc_open_file (GstDiskSrc *src)
{ {
struct stat f_stat; g_return_val_if_fail (!GST_FLAG_IS_SET (src ,GST_DISKSRC_OPEN), FALSE);
g_return_val_if_fail (!GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), FALSE);
g_return_val_if_fail (src->filename != NULL, FALSE);
/* open the file */ /* open the file */
src->fd = open (src->filename, O_RDONLY); src->fd = open (src->filename, O_RDONLY);
if (src->fd < 0) { if (src->fd < 0) {
perror ("open()"); perror ("open");
gst_element_error (GST_ELEMENT (src), "opening file"); gst_element_error (GST_ELEMENT (src), g_strconcat("opening file \"", src->filename, "\"", NULL));
return FALSE; return FALSE;
} else {
/* find the file length */
src->size = lseek (src->fd, 0, SEEK_END);
lseek (src->fd, 0, SEEK_SET);
/* map the file into memory */
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) {
close (src->fd);
gst_element_error (GST_ELEMENT (src),"mmapping file");
return FALSE;
}
GST_FLAG_SET (src, GST_DISKSRC_OPEN);
src->new_seek = TRUE;
} }
if (fstat (src->fd, &f_stat) < 0) {
perror("fstat()");
}
else {
src->size = f_stat.st_size;
GST_DEBUG (0,"gstdisksrc: file size %ld\n", src->size);
}
GST_FLAG_SET (src, GST_DISKSRC_OPEN);
return TRUE; return TRUE;
} }
/* close the file */ /* unmap and close the file */
static void static void
gst_disksrc_close_file (GstDiskSrc *src) gst_disksrc_close_file (GstDiskSrc *src)
{ {
g_return_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN)); g_return_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN));
/* unmap the file from memory */
munmap (src->map, src->size);
/* close the file */ /* close the file */
close (src->fd); close (src->fd);
/* zero out a lot of our state */ /* zero out a lot of our state */
src->fd = 0; src->fd = 0;
src->size = 0;
src->map = NULL;
src->curoffset = 0; src->curoffset = 0;
src->seq = 0; src->seq = 0;
src->size = 0; src->new_seek = FALSE;
GST_FLAG_UNSET (src, GST_DISKSRC_OPEN); GST_FLAG_UNSET (src, GST_DISKSRC_OPEN);
} }
static GstElementStateReturn static GstElementStateReturn
gst_disksrc_change_state (GstElement *element) gst_disksrc_change_state (GstElement *element)
{ {
g_return_val_if_fail (GST_IS_DISKSRC (element), GST_STATE_FAILURE); g_return_val_if_fail (GST_IS_DISKSRC (element), GST_STATE_FAILURE);
GST_DEBUG (0,"gstdisksrc: state pending %d\n", GST_STATE_PENDING (element));
/* if going down into NULL state, close the file if it's open */
if (GST_STATE_PENDING (element) == GST_STATE_NULL) { if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
if (GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN)) if (GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN))
gst_disksrc_close_file (GST_DISKSRC (element)); gst_disksrc_close_file (GST_DISKSRC (element));
/* otherwise (READY or higher) we need to open the file */
} else { } else {
if (!GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN)) { if (!GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN)) {
if (!gst_disksrc_open_file (GST_DISKSRC (element))) if (!gst_disksrc_open_file (GST_DISKSRC (element)))
return GST_STATE_FAILURE; return GST_STATE_FAILURE;
} }
} }
/* if we haven't failed already, give the parent class a chance to ;-) */
if (GST_ELEMENT_CLASS (parent_class)->change_state) if (GST_ELEMENT_CLASS (parent_class)->change_state)
return GST_ELEMENT_CLASS (parent_class)->change_state (element); return GST_ELEMENT_CLASS (parent_class)->change_state (element);

15
plugins/elements/gstdisksrc.h
View file

@ -25,7 +25,6 @@
#define __GST_DISKSRC_H__ #define __GST_DISKSRC_H__
#include <config.h>
#include <gst/gst.h> #include <gst/gst.h>
@ -34,8 +33,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
extern GstElementDetails gst_disksrc_details; GstElementDetails gst_disksrc_details;
#define GST_TYPE_DISKSRC \ #define GST_TYPE_DISKSRC \
(gst_disksrc_get_type()) (gst_disksrc_get_type())
@ -51,7 +49,7 @@ extern GstElementDetails gst_disksrc_details;
typedef enum { typedef enum {
GST_DISKSRC_OPEN = GST_ELEMENT_FLAG_LAST, GST_DISKSRC_OPEN = GST_ELEMENT_FLAG_LAST,
GST_DISKSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST+2, GST_DISKSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
} GstDiskSrcFlags; } GstDiskSrcFlags;
typedef struct _GstDiskSrc GstDiskSrc; typedef struct _GstDiskSrc GstDiskSrc;
@ -62,16 +60,21 @@ struct _GstDiskSrc {
/* pads */ /* pads */
GstPad *srcpad; GstPad *srcpad;
/* file state */ /* filename */
gchar *filename; gchar *filename;
/* fd */
gint fd; gint fd;
/* mapping parameters */
gulong size; /* how long is the file? */
guchar *map; /* where the file is mapped to */
/* details for fallback synchronous read */
gulong curoffset; /* current offset in file */ gulong curoffset; /* current offset in file */
gulong bytes_per_read; /* bytes per read */ gulong bytes_per_read; /* bytes per read */
gboolean new_seek; gboolean new_seek;
gulong seq; /* buffer sequence number */ gulong seq; /* buffer sequence number */
gulong size;
}; };
struct _GstDiskSrcClass { struct _GstDiskSrcClass {

25
plugins/elements/gstelements.c
View file

@ -23,7 +23,6 @@
#include <gst/gst.h> #include <gst/gst.h>
#include "gstasyncdisksrc.h"
#include "gstaudiosink.h" #include "gstaudiosink.h"
#include "gstaudiosrc.h" #include "gstaudiosrc.h"
#include "gstdisksrc.h" #include "gstdisksrc.h"
@ -49,18 +48,18 @@ struct _elements_entry {
}; };
static struct _elements_entry _elements[] = { static struct _elements_entry _elements[] = {
{ "fakesrc", gst_fakesrc_get_type, &gst_fakesrc_details, NULL }, { "fakesrc", gst_fakesrc_get_type, &gst_fakesrc_details, NULL },
{ "fakesink", gst_fakesink_get_type, &gst_fakesink_details, NULL }, { "fakesink", gst_fakesink_get_type, &gst_fakesink_details, NULL },
{ "asyncdisksrc", gst_asyncdisksrc_get_type, &gst_asyncdisksrc_details, NULL }, { "asyncdisksrc", gst_disksrc_get_type, &gst_disksrc_details, NULL },
{ "audiosink", gst_audiosink_get_type, &gst_audiosink_details, gst_audiosink_factory_init }, { "audiosink", gst_audiosink_get_type, &gst_audiosink_details, gst_audiosink_factory_init },
{ "audiosrc", gst_audiosrc_get_type, &gst_audiosrc_details, NULL }, { "audiosrc", gst_audiosrc_get_type, &gst_audiosrc_details, NULL },
{ "disksrc", gst_disksrc_get_type, &gst_disksrc_details, NULL }, { "disksrc", gst_disksrc_get_type, &gst_disksrc_details, NULL },
{ "identity", gst_identity_get_type, &gst_identity_details, NULL }, { "identity", gst_identity_get_type, &gst_identity_details, NULL },
{ "fdsink", gst_fdsink_get_type, &gst_fdsink_details, NULL }, { "fdsink", gst_fdsink_get_type, &gst_fdsink_details, NULL },
{ "fdsrc", gst_fdsrc_get_type, &gst_fdsrc_details, NULL }, { "fdsrc", gst_fdsrc_get_type, &gst_fdsrc_details, NULL },
{ "pipefilter", gst_pipefilter_get_type, &gst_pipefilter_details, NULL }, { "pipefilter", gst_pipefilter_get_type, &gst_pipefilter_details, NULL },
{ "sinesrc", gst_sinesrc_get_type, &gst_sinesrc_details, NULL }, { "sinesrc", gst_sinesrc_get_type, &gst_sinesrc_details, NULL },
{ "tee", gst_tee_get_type, &gst_tee_details, gst_tee_factory_init }, { "tee", gst_tee_get_type, &gst_tee_details, gst_tee_factory_init },
#if HAVE_LIBGHTTP #if HAVE_LIBGHTTP
{ "httpsrc", gst_httpsrc_get_type, &gst_httpsrc_details, NULL }, { "httpsrc", gst_httpsrc_get_type, &gst_httpsrc_details, NULL },