2000-12-29 05:38:06 +00:00
|
|
|
/* GStreamer
|
|
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
|
|
*
|
2001-03-07 21:52:56 +00:00
|
|
|
* gstdisksrc.c:
|
2000-01-30 09:03:00 +00:00
|
|
|
*
|
|
|
|
* 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>
|
2000-02-27 23:18:38 +00:00
|
|
|
#include <unistd.h>
|
2001-02-04 21:37:14 +00:00
|
|
|
#include <sys/mman.h>
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
//#define GST_DEBUG_ENABLED
|
|
|
|
|
|
|
|
#include "gstdisksrc.h"
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
|
|
|
|
GstElementDetails gst_disksrc_details = {
|
2001-02-21 20:28:31 +00:00
|
|
|
"Disk Source",
|
2000-01-30 09:03:00 +00:00
|
|
|
"Source/File",
|
2001-02-04 21:37:14 +00:00
|
|
|
"Read from arbitrary point in a file",
|
2000-01-30 09:03:00 +00:00
|
|
|
VERSION,
|
|
|
|
"Erik Walthinsen <omega@cse.ogi.edu>",
|
|
|
|
"(C) 1999",
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* DiskSrc signals and args */
|
|
|
|
enum {
|
|
|
|
/* FILL ME */
|
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
ARG_0,
|
|
|
|
ARG_LOCATION,
|
|
|
|
ARG_BYTESPERREAD,
|
|
|
|
ARG_OFFSET,
|
2000-07-05 10:21:08 +00:00
|
|
|
ARG_SIZE,
|
2000-01-30 09:03:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2001-07-11 14:56:16 +00:00
|
|
|
static void gst_disksrc_class_init (GstDiskSrcClass *klass);
|
2001-03-07 21:52:56 +00:00
|
|
|
static void gst_disksrc_init (GstDiskSrc *disksrc);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-07-11 14:56:16 +00:00
|
|
|
static void gst_disksrc_set_property (GObject *object, guint prop_id,
|
|
|
|
const GValue *value, GParamSpec *pspec);
|
|
|
|
static void gst_disksrc_get_property (GObject *object, guint prop_id,
|
|
|
|
GValue *value, GParamSpec *pspec);
|
2000-11-06 00:15:51 +00:00
|
|
|
|
2001-07-11 14:56:16 +00:00
|
|
|
static GstBuffer * gst_disksrc_get (GstPad *pad);
|
|
|
|
static GstBuffer * gst_disksrc_get_region (GstPad *pad,GstRegionType type,guint64 offset,guint64 len);
|
2000-11-06 00:15:51 +00:00
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
static GstElementStateReturn gst_disksrc_change_state (GstElement *element);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-07-11 14:56:16 +00:00
|
|
|
static gboolean gst_disksrc_open_file (GstDiskSrc *src);
|
|
|
|
static void gst_disksrc_close_file (GstDiskSrc *src);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-12-29 02:28:04 +00:00
|
|
|
static GstElementClass *parent_class = NULL;
|
2000-02-27 23:18:38 +00:00
|
|
|
//static guint gst_disksrc_signals[LAST_SIGNAL] = { 0 };
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
GType
|
2001-03-07 21:52:56 +00:00
|
|
|
gst_disksrc_get_type(void)
|
2001-02-04 21:37:14 +00:00
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
static GType disksrc_type = 0;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
if (!disksrc_type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
static const GTypeInfo disksrc_info = {
|
|
|
|
sizeof(GstDiskSrcClass), NULL,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc)gst_disksrc_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
2000-01-30 09:03:00 +00:00
|
|
|
sizeof(GstDiskSrc),
|
2001-06-25 01:20:11 +00:00
|
|
|
0,
|
|
|
|
(GInstanceInitFunc)gst_disksrc_init,
|
2000-01-30 09:03:00 +00:00
|
|
|
};
|
2001-06-25 01:20:11 +00:00
|
|
|
disksrc_type = g_type_register_static (GST_TYPE_ELEMENT, "GstDiskSrc", &disksrc_info, 0);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
return disksrc_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-03-07 21:52:56 +00:00
|
|
|
gst_disksrc_class_init (GstDiskSrcClass *klass)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GObjectClass *gobject_class;
|
2000-01-30 09:03:00 +00:00
|
|
|
GstElementClass *gstelement_class;
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class = (GObjectClass*)klass;
|
2000-01-30 09:03:00 +00:00
|
|
|
gstelement_class = (GstElementClass*)klass;
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_LOCATION,
|
|
|
|
g_param_spec_string("location","location","location",
|
|
|
|
NULL,G_PARAM_READWRITE)); // CHECKME!
|
|
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BYTESPERREAD,
|
|
|
|
g_param_spec_int("bytesperread","bytesperread","bytesperread",
|
|
|
|
G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
|
|
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_OFFSET,
|
|
|
|
g_param_spec_long("offset","offset","offset",
|
|
|
|
G_MINLONG,G_MAXLONG,0,G_PARAM_READWRITE)); // CHECKME
|
|
|
|
g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SIZE,
|
|
|
|
g_param_spec_long("size","size","size",
|
|
|
|
G_MINLONG,G_MAXLONG,0,G_PARAM_READABLE)); // CHECKME
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class->set_property = gst_disksrc_set_property;
|
|
|
|
gobject_class->get_property = gst_disksrc_get_property;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
gstelement_class->change_state = gst_disksrc_change_state;
|
|
|
|
}
|
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
static void
|
|
|
|
gst_disksrc_init (GstDiskSrc *disksrc)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
2001-02-04 21:37:14 +00:00
|
|
|
// GST_FLAG_SET (disksrc, GST_SRC_);
|
|
|
|
|
2000-11-20 19:04:32 +00:00
|
|
|
disksrc->srcpad = gst_pad_new ("src", GST_PAD_SRC);
|
2001-02-04 21:37:14 +00:00
|
|
|
gst_pad_set_get_function (disksrc->srcpad,gst_disksrc_get);
|
|
|
|
gst_pad_set_getregion_function (disksrc->srcpad,gst_disksrc_get_region);
|
2000-11-20 19:04:32 +00:00
|
|
|
gst_element_add_pad (GST_ELEMENT (disksrc), disksrc->srcpad);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
disksrc->filename = NULL;
|
|
|
|
disksrc->fd = 0;
|
2001-02-04 21:37:14 +00:00
|
|
|
disksrc->size = 0;
|
|
|
|
disksrc->map = NULL;
|
2000-01-30 09:03:00 +00:00
|
|
|
disksrc->curoffset = 0;
|
|
|
|
disksrc->bytes_per_read = 4096;
|
|
|
|
disksrc->seq = 0;
|
2000-07-05 10:21:08 +00:00
|
|
|
disksrc->new_seek = FALSE;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
static void
|
2001-06-25 01:20:11 +00:00
|
|
|
gst_disksrc_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GstDiskSrc *src;
|
|
|
|
|
|
|
|
/* it's not null if we got it, but it might not be ours */
|
2000-11-20 19:04:32 +00:00
|
|
|
g_return_if_fail (GST_IS_DISKSRC (object));
|
2001-03-07 21:52:56 +00:00
|
|
|
|
2000-11-20 19:04:32 +00:00
|
|
|
src = GST_DISKSRC (object);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
switch (prop_id) {
|
2000-01-30 09:03:00 +00:00
|
|
|
case ARG_LOCATION:
|
2001-05-22 19:22:57 +00:00
|
|
|
/* 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));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-20 19:04:32 +00:00
|
|
|
if (src->filename) g_free (src->filename);
|
2000-01-30 09:03:00 +00:00
|
|
|
/* clear the filename if we get a NULL (is that possible?) */
|
2001-06-25 01:20:11 +00:00
|
|
|
if (g_value_get_string (value) == NULL) {
|
2000-11-20 19:04:32 +00:00
|
|
|
gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
src->filename = NULL;
|
|
|
|
/* otherwise set the new filename */
|
|
|
|
} else {
|
2001-06-25 01:20:11 +00:00
|
|
|
src->filename = g_strdup (g_value_get_string (value));
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-05-22 19:22:57 +00:00
|
|
|
if ((GST_STATE (src) == GST_STATE_PAUSED) && (src->filename != NULL))
|
|
|
|
{
|
|
|
|
gst_disksrc_close_file(src);
|
|
|
|
gst_disksrc_open_file(src);
|
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
|
|
|
case ARG_BYTESPERREAD:
|
2001-06-25 01:20:11 +00:00
|
|
|
src->bytes_per_read = g_value_get_int (value);
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2000-06-25 21:38:00 +00:00
|
|
|
case ARG_OFFSET:
|
2001-06-25 01:20:11 +00:00
|
|
|
src->curoffset = g_value_get_long (value);
|
2000-07-05 10:21:08 +00:00
|
|
|
src->new_seek = TRUE;
|
2000-06-25 21:38:00 +00:00
|
|
|
break;
|
2000-01-30 09:03:00 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
static void
|
2001-06-25 01:20:11 +00:00
|
|
|
gst_disksrc_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
GstDiskSrc *src;
|
|
|
|
|
|
|
|
/* it's not null if we got it, but it might not be ours */
|
2000-11-20 19:04:32 +00:00
|
|
|
g_return_if_fail (GST_IS_DISKSRC (object));
|
2001-03-07 21:52:56 +00:00
|
|
|
|
2000-11-20 19:04:32 +00:00
|
|
|
src = GST_DISKSRC (object);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
switch (prop_id) {
|
2000-01-30 09:03:00 +00:00
|
|
|
case ARG_LOCATION:
|
2001-06-25 01:20:11 +00:00
|
|
|
g_value_set_string (value, src->filename);
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
|
|
|
case ARG_BYTESPERREAD:
|
2001-06-25 01:20:11 +00:00
|
|
|
g_value_set_int (value, src->bytes_per_read);
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
|
|
|
case ARG_OFFSET:
|
2001-06-25 01:20:11 +00:00
|
|
|
g_value_set_long (value, src->curoffset);
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
2000-07-05 10:21:08 +00:00
|
|
|
case ARG_SIZE:
|
2001-06-25 01:20:11 +00:00
|
|
|
g_value_set_long (value, src->size);
|
2000-07-05 10:21:08 +00:00
|
|
|
break;
|
2000-01-30 09:03:00 +00:00
|
|
|
default:
|
2001-06-25 01:20:11 +00:00
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
2000-01-30 09:03:00 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/**
|
|
|
|
* gst_disksrc_get:
|
|
|
|
* @pad: #GstPad to push a buffer from
|
|
|
|
*
|
|
|
|
* Push a new buffer from the disksrc at the current offset.
|
|
|
|
*/
|
2000-12-20 09:39:43 +00:00
|
|
|
static GstBuffer *
|
2001-03-07 21:52:56 +00:00
|
|
|
gst_disksrc_get (GstPad *pad)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
Changed the way things are scheduled, especially sources. A Src used to have a push() function, and optionally a pus...
Original commit message from CVS:
Changed the way things are scheduled, especially sources. A Src used to
have a push() function, and optionally a pushregion() to deal with async
reads, etc. That whole thing has gone away, in favor of providing a
pull() function for the output (Src) pad instead, ala chain functions.
This makes constructing cothreaded schedules out of non-loop elements
somewhat easier. Basically there was always a question as to which pad
was being dealt with. In the pullregion case, cothread-specific data was
used to try to pass the region struct to the right place, which is a slow
hack. And in general, the push function severely limited the kind of
tricks that could be played when there's more than one output pad, such as
a multi-out file reader with async capabilities on each pad independently.
This changes the way cothread scheduling occurs. Instead of the hack to
deal with Src's by calling their push() function (or optionally the
pushregion(), in certain cases), we now are working towards a general
mechanism where pads are the only thing that are dealt with directly.
An optimization was made in the process of doing this: the loopfunction
actually run as the outer [stack] frame of the cothread is now set more
intelligently in create_plan() based on what kind of element it is. We
now have:
loopfunc_wrapper: used for loop-based elements, it simply calls the
loopfunc in a loop, paying attention to COTHREAD_STOPPING (see
below). It currently does other, soon to be depracated, stuff.
pullsrc_wrapper: wraps a Src that's not loop-based (since your options
are now loop- or pull-based)
There will be a couple more to deal with other cases, such as Connections
and chain-based elements. The general idea is that it's a lot more
efficient to make the decisions once in create_plan than to keep doing
this huge if/else chain in the wrapper. Just choose the right wrapper up
front. It'll be most apparent performance-wise in the case of whichever
element context is switched to first for each iteration, since the whole
wrapper setup is done for every iteration.
The tricky part is that there is now a bit of overloading of the function
pointers in a pad. The current meanings (possibly to change a bit more
soon) are:
chainfunc: as always, chainfunc pointer is mirrored between peer pads
(this may change, and the chain func may end up in pushfunc)
pushfunc: SrcPad: gst_pad_pushfunc_proxy, cothread_switch to peer
SinkPad: none (may take over chainfunc, see below) pullfunc:
SrcPad: Src or Connection's function to construct buffers
SinkPad: gst_pad_pullfunc_proxy, cothread_switch to peer
There are a number of issues remaining with the scheduling, not the least
of which is the fact that Connections are still dealt with the old way,
with _push() functions and such. I'm trying to figure out a way to unify
the system so it makes sense. Following the scheduling system is hard
enough, trying to change it is murder.
Another useful scheduling addition, mentioned above, is COTHREAD_STOPPING.
It's an element flag that's used to signal whatever code is running in
cothread context that it should be finishing up and exiting soon. An
example of this is in plugins/cobin/spindentity.c. All the loops should
now be composed of do/while loops, rather than while(1) loops:
do {
buf = gst_pad_pull(spindentity->sinkpad);
gst_pad_push(spindentity->srcpad,buf);
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING(element));
The reason for this is that COTHREAD_STOPPING may be set before the above
loop ever gets started. It wouldn't do for the body of the loop to never
once get called, that would simply stall the pipeline. Note that only the
core library code is ever responsible for setting and unsetting this flag.
All elements have to do is respond to it by cleanly exiting the loop and
the function holding it.
This is needed primarily to allow iterations to occur properly.
Basically, there's a single entry point in the cothread scheduling loop,
gst_bin_iterate_func() simply switches to this cothread. If the element
in this context is allowed to loop infinitely, nothing would even switch
back to the context from which the iterate() was originally called. This
is a bit of a problem. The solution is for there to be an implicit switch
back to the originating context. Now, even I'm not sure exactly how this
works, but if the cothread that's switched to actually returns, execution
returns back to the calling context, i.e. iterate_func().
COTHREAD_STOPPING is therefore set just before switching into this
(currently randomly chosen) context, on the assumption that it will return
promptly after finishing its duties. The burden of clearing the flag
falls to the various wrapper functions provided by the Bin code, thus
element writers don't have to worry about doing that at all (and simply
shouldn't).
Related changes:
All the sources in elements/ have been changed to reflect the new system.
FIXMEs:
1) gstpipeline.c calls gst_src_push at some point, dunno why, it's
commented out now.
2) any other sources, including vcdsrc, dvdsrc, and v4lsrc will break
badly and need to be modified to work as pull-based sources.
2000-12-04 10:52:30 +00:00
|
|
|
GstDiskSrc *src;
|
2000-01-30 09:03:00 +00:00
|
|
|
GstBuffer *buf;
|
|
|
|
|
2000-12-23 03:17:52 +00:00
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
2001-02-04 21:37:14 +00:00
|
|
|
src = GST_DISKSRC (gst_pad_get_parent (pad));
|
2000-12-23 03:17:52 +00:00
|
|
|
g_return_val_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN), NULL);
|
2001-02-04 21:37:14 +00:00
|
|
|
|
2001-06-15 19:13:45 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/* deal with EOF state */
|
|
|
|
if (src->curoffset >= src->size) {
|
2001-06-15 19:13:45 +00:00
|
|
|
GST_DEBUG (0,"map offset %ld >= size %ld --> eos\n", src->curoffset, src->size);
|
2001-03-07 21:52:56 +00:00
|
|
|
gst_pad_set_eos (pad);
|
2001-06-30 00:35:55 +00:00
|
|
|
buf = gst_buffer_new();
|
|
|
|
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_EOS);
|
|
|
|
return buf;
|
2001-02-04 21:37:14 +00:00
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* create the buffer */
|
|
|
|
// FIXME: should eventually use a bufferpool for this
|
2000-11-20 19:04:32 +00:00
|
|
|
buf = gst_buffer_new ();
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
g_return_val_if_fail (buf != NULL, NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/* 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);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
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);
|
2000-07-05 10:21:08 +00:00
|
|
|
|
Changed the way things are scheduled, especially sources. A Src used to have a push() function, and optionally a pus...
Original commit message from CVS:
Changed the way things are scheduled, especially sources. A Src used to
have a push() function, and optionally a pushregion() to deal with async
reads, etc. That whole thing has gone away, in favor of providing a
pull() function for the output (Src) pad instead, ala chain functions.
This makes constructing cothreaded schedules out of non-loop elements
somewhat easier. Basically there was always a question as to which pad
was being dealt with. In the pullregion case, cothread-specific data was
used to try to pass the region struct to the right place, which is a slow
hack. And in general, the push function severely limited the kind of
tricks that could be played when there's more than one output pad, such as
a multi-out file reader with async capabilities on each pad independently.
This changes the way cothread scheduling occurs. Instead of the hack to
deal with Src's by calling their push() function (or optionally the
pushregion(), in certain cases), we now are working towards a general
mechanism where pads are the only thing that are dealt with directly.
An optimization was made in the process of doing this: the loopfunction
actually run as the outer [stack] frame of the cothread is now set more
intelligently in create_plan() based on what kind of element it is. We
now have:
loopfunc_wrapper: used for loop-based elements, it simply calls the
loopfunc in a loop, paying attention to COTHREAD_STOPPING (see
below). It currently does other, soon to be depracated, stuff.
pullsrc_wrapper: wraps a Src that's not loop-based (since your options
are now loop- or pull-based)
There will be a couple more to deal with other cases, such as Connections
and chain-based elements. The general idea is that it's a lot more
efficient to make the decisions once in create_plan than to keep doing
this huge if/else chain in the wrapper. Just choose the right wrapper up
front. It'll be most apparent performance-wise in the case of whichever
element context is switched to first for each iteration, since the whole
wrapper setup is done for every iteration.
The tricky part is that there is now a bit of overloading of the function
pointers in a pad. The current meanings (possibly to change a bit more
soon) are:
chainfunc: as always, chainfunc pointer is mirrored between peer pads
(this may change, and the chain func may end up in pushfunc)
pushfunc: SrcPad: gst_pad_pushfunc_proxy, cothread_switch to peer
SinkPad: none (may take over chainfunc, see below) pullfunc:
SrcPad: Src or Connection's function to construct buffers
SinkPad: gst_pad_pullfunc_proxy, cothread_switch to peer
There are a number of issues remaining with the scheduling, not the least
of which is the fact that Connections are still dealt with the old way,
with _push() functions and such. I'm trying to figure out a way to unify
the system so it makes sense. Following the scheduling system is hard
enough, trying to change it is murder.
Another useful scheduling addition, mentioned above, is COTHREAD_STOPPING.
It's an element flag that's used to signal whatever code is running in
cothread context that it should be finishing up and exiting soon. An
example of this is in plugins/cobin/spindentity.c. All the loops should
now be composed of do/while loops, rather than while(1) loops:
do {
buf = gst_pad_pull(spindentity->sinkpad);
gst_pad_push(spindentity->srcpad,buf);
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING(element));
The reason for this is that COTHREAD_STOPPING may be set before the above
loop ever gets started. It wouldn't do for the body of the loop to never
once get called, that would simply stall the pipeline. Note that only the
core library code is ever responsible for setting and unsetting this flag.
All elements have to do is respond to it by cleanly exiting the loop and
the function holding it.
This is needed primarily to allow iterations to occur properly.
Basically, there's a single entry point in the cothread scheduling loop,
gst_bin_iterate_func() simply switches to this cothread. If the element
in this context is allowed to loop infinitely, nothing would even switch
back to the context from which the iterate() was originally called. This
is a bit of a problem. The solution is for there to be an implicit switch
back to the originating context. Now, even I'm not sure exactly how this
works, but if the cothread that's switched to actually returns, execution
returns back to the calling context, i.e. iterate_func().
COTHREAD_STOPPING is therefore set just before switching into this
(currently randomly chosen) context, on the assumption that it will return
promptly after finishing its duties. The burden of clearing the flag
falls to the various wrapper functions provided by the Bin code, thus
element writers don't have to worry about doing that at all (and simply
shouldn't).
Related changes:
All the sources in elements/ have been changed to reflect the new system.
FIXMEs:
1) gstpipeline.c calls gst_src_push at some point, dunno why, it's
commented out now.
2) any other sources, including vcdsrc, dvdsrc, and v4lsrc will break
badly and need to be modified to work as pull-based sources.
2000-12-04 10:52:30 +00:00
|
|
|
if (src->new_seek) {
|
2000-11-20 19:04:32 +00:00
|
|
|
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLUSH);
|
2001-02-04 21:37:14 +00:00
|
|
|
GST_DEBUG (0,"new seek\n");
|
Changed the way things are scheduled, especially sources. A Src used to have a push() function, and optionally a pus...
Original commit message from CVS:
Changed the way things are scheduled, especially sources. A Src used to
have a push() function, and optionally a pushregion() to deal with async
reads, etc. That whole thing has gone away, in favor of providing a
pull() function for the output (Src) pad instead, ala chain functions.
This makes constructing cothreaded schedules out of non-loop elements
somewhat easier. Basically there was always a question as to which pad
was being dealt with. In the pullregion case, cothread-specific data was
used to try to pass the region struct to the right place, which is a slow
hack. And in general, the push function severely limited the kind of
tricks that could be played when there's more than one output pad, such as
a multi-out file reader with async capabilities on each pad independently.
This changes the way cothread scheduling occurs. Instead of the hack to
deal with Src's by calling their push() function (or optionally the
pushregion(), in certain cases), we now are working towards a general
mechanism where pads are the only thing that are dealt with directly.
An optimization was made in the process of doing this: the loopfunction
actually run as the outer [stack] frame of the cothread is now set more
intelligently in create_plan() based on what kind of element it is. We
now have:
loopfunc_wrapper: used for loop-based elements, it simply calls the
loopfunc in a loop, paying attention to COTHREAD_STOPPING (see
below). It currently does other, soon to be depracated, stuff.
pullsrc_wrapper: wraps a Src that's not loop-based (since your options
are now loop- or pull-based)
There will be a couple more to deal with other cases, such as Connections
and chain-based elements. The general idea is that it's a lot more
efficient to make the decisions once in create_plan than to keep doing
this huge if/else chain in the wrapper. Just choose the right wrapper up
front. It'll be most apparent performance-wise in the case of whichever
element context is switched to first for each iteration, since the whole
wrapper setup is done for every iteration.
The tricky part is that there is now a bit of overloading of the function
pointers in a pad. The current meanings (possibly to change a bit more
soon) are:
chainfunc: as always, chainfunc pointer is mirrored between peer pads
(this may change, and the chain func may end up in pushfunc)
pushfunc: SrcPad: gst_pad_pushfunc_proxy, cothread_switch to peer
SinkPad: none (may take over chainfunc, see below) pullfunc:
SrcPad: Src or Connection's function to construct buffers
SinkPad: gst_pad_pullfunc_proxy, cothread_switch to peer
There are a number of issues remaining with the scheduling, not the least
of which is the fact that Connections are still dealt with the old way,
with _push() functions and such. I'm trying to figure out a way to unify
the system so it makes sense. Following the scheduling system is hard
enough, trying to change it is murder.
Another useful scheduling addition, mentioned above, is COTHREAD_STOPPING.
It's an element flag that's used to signal whatever code is running in
cothread context that it should be finishing up and exiting soon. An
example of this is in plugins/cobin/spindentity.c. All the loops should
now be composed of do/while loops, rather than while(1) loops:
do {
buf = gst_pad_pull(spindentity->sinkpad);
gst_pad_push(spindentity->srcpad,buf);
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING(element));
The reason for this is that COTHREAD_STOPPING may be set before the above
loop ever gets started. It wouldn't do for the body of the loop to never
once get called, that would simply stall the pipeline. Note that only the
core library code is ever responsible for setting and unsetting this flag.
All elements have to do is respond to it by cleanly exiting the loop and
the function holding it.
This is needed primarily to allow iterations to occur properly.
Basically, there's a single entry point in the cothread scheduling loop,
gst_bin_iterate_func() simply switches to this cothread. If the element
in this context is allowed to loop infinitely, nothing would even switch
back to the context from which the iterate() was originally called. This
is a bit of a problem. The solution is for there to be an implicit switch
back to the originating context. Now, even I'm not sure exactly how this
works, but if the cothread that's switched to actually returns, execution
returns back to the calling context, i.e. iterate_func().
COTHREAD_STOPPING is therefore set just before switching into this
(currently randomly chosen) context, on the assumption that it will return
promptly after finishing its duties. The burden of clearing the flag
falls to the various wrapper functions provided by the Bin code, thus
element writers don't have to worry about doing that at all (and simply
shouldn't).
Related changes:
All the sources in elements/ have been changed to reflect the new system.
FIXMEs:
1) gstpipeline.c calls gst_src_push at some point, dunno why, it's
commented out now.
2) any other sources, including vcdsrc, dvdsrc, and v4lsrc will break
badly and need to be modified to work as pull-based sources.
2000-12-04 10:52:30 +00:00
|
|
|
src->new_seek = FALSE;
|
2000-07-05 10:21:08 +00:00
|
|
|
}
|
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/* we're done, return the buffer */
|
|
|
|
return buf;
|
|
|
|
}
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/**
|
|
|
|
* gst_disksrc_get_region:
|
|
|
|
* @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 *
|
2001-03-07 21:52:56 +00:00
|
|
|
gst_disksrc_get_region (GstPad *pad, GstRegionType type,guint64 offset,guint64 len)
|
2001-02-04 21:37:14 +00:00
|
|
|
{
|
|
|
|
GstDiskSrc *src;
|
|
|
|
GstBuffer *buf;
|
|
|
|
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
2001-02-05 17:16:23 +00:00
|
|
|
g_return_val_if_fail (type == GST_REGION_OFFSET_LEN, NULL);
|
2001-02-04 21:37:14 +00:00
|
|
|
|
|
|
|
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);
|
2001-03-07 21:52:56 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/* deal with EOF state */
|
|
|
|
if (offset >= src->size) {
|
2001-06-15 19:13:45 +00:00
|
|
|
//gst_pad_set_eos (pad);
|
|
|
|
GST_DEBUG (0,"map offset %lld >= size %ld --> eos\n", offset, src->size);
|
|
|
|
//FIXME
|
|
|
|
buf = gst_buffer_new();
|
|
|
|
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_EOS);
|
|
|
|
return buf;
|
2001-02-04 21:37:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2001-02-05 17:16:23 +00:00
|
|
|
if ((offset + len) > src->size) {
|
2001-02-04 21:37:14 +00:00
|
|
|
GST_BUFFER_SIZE (buf) = src->size - offset;
|
|
|
|
// FIXME: set the buffer's EOF bit here
|
|
|
|
} else
|
2001-02-05 17:16:23 +00:00
|
|
|
GST_BUFFER_SIZE (buf) = len;
|
2001-02-04 21:37:14 +00:00
|
|
|
|
2001-02-05 17:16:23 +00:00
|
|
|
GST_DEBUG (0,"map %p, offset %lld, size %d\n", src->map, offset, GST_BUFFER_SIZE (buf));
|
2001-02-04 21:37:14 +00:00
|
|
|
|
|
|
|
/* we're done, return the buffer off now */
|
2000-12-20 09:39:43 +00:00
|
|
|
return buf;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/* open the file and mmap it, necessary to go to READY state */
|
2001-04-22 16:04:19 +00:00
|
|
|
static gboolean
|
|
|
|
gst_disksrc_open_file (GstDiskSrc *src)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
2001-02-04 21:37:14 +00:00
|
|
|
g_return_val_if_fail (!GST_FLAG_IS_SET (src ,GST_DISKSRC_OPEN), FALSE);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* open the file */
|
2000-11-20 19:04:32 +00:00
|
|
|
src->fd = open (src->filename, O_RDONLY);
|
2000-01-30 09:03:00 +00:00
|
|
|
if (src->fd < 0) {
|
2001-02-04 21:37:14 +00:00
|
|
|
perror ("open");
|
|
|
|
gst_element_error (GST_ELEMENT (src), g_strconcat("opening file \"", src->filename, "\"", NULL));
|
2000-01-30 09:03:00 +00:00
|
|
|
return FALSE;
|
2001-02-04 21:37:14 +00:00
|
|
|
} 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;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/* unmap and close the file */
|
2001-03-07 21:52:56 +00:00
|
|
|
static void
|
|
|
|
gst_disksrc_close_file (GstDiskSrc *src)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (GST_FLAG_IS_SET (src, GST_DISKSRC_OPEN));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
/* unmap the file from memory */
|
|
|
|
munmap (src->map, src->size);
|
2000-01-30 09:03:00 +00:00
|
|
|
/* close the file */
|
2000-11-20 19:04:32 +00:00
|
|
|
close (src->fd);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* zero out a lot of our state */
|
|
|
|
src->fd = 0;
|
2001-02-04 21:37:14 +00:00
|
|
|
src->size = 0;
|
|
|
|
src->map = NULL;
|
2000-01-30 09:03:00 +00:00
|
|
|
src->curoffset = 0;
|
|
|
|
src->seq = 0;
|
2001-02-04 21:37:14 +00:00
|
|
|
src->new_seek = FALSE;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-20 19:04:32 +00:00
|
|
|
GST_FLAG_UNSET (src, GST_DISKSRC_OPEN);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-02-04 21:37:14 +00:00
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
static GstElementStateReturn
|
|
|
|
gst_disksrc_change_state (GstElement *element)
|
2000-11-20 19:04:32 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (GST_IS_DISKSRC (element), GST_STATE_FAILURE);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-20 19:04:32 +00:00
|
|
|
if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
|
|
|
|
if (GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN))
|
|
|
|
gst_disksrc_close_file (GST_DISKSRC (element));
|
2000-07-21 03:57:51 +00:00
|
|
|
} else {
|
2000-11-20 19:04:32 +00:00
|
|
|
if (!GST_FLAG_IS_SET (element, GST_DISKSRC_OPEN)) {
|
2001-03-07 21:52:56 +00:00
|
|
|
if (!gst_disksrc_open_file (GST_DISKSRC (element)))
|
2000-07-21 03:57:51 +00:00
|
|
|
return GST_STATE_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-11-20 19:04:32 +00:00
|
|
|
if (GST_ELEMENT_CLASS (parent_class)->change_state)
|
|
|
|
return GST_ELEMENT_CLASS (parent_class)->change_state (element);
|
2000-07-21 03:57:51 +00:00
|
|
|
|
|
|
|
return GST_STATE_SUCCESS;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|