mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-06-23 00:10:40 +00:00
4118c5130e
Original commit message from CVS: gstautoplugcache.c: Set default for cache's caps_proxy to FALSE again. gstautoplugger.c: Fixed with strategic positioning of gst_pad_set_caps()
372 lines
12 KiB
C
372 lines
12 KiB
C
/* GStreamer
|
|
* Copyright (C) 2001 RidgeRun, Inc. (www.ridgerun.com)
|
|
*
|
|
* gstautoplugcache.c: Data cache for the dynamic autoplugger
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <gst/gst.h>
|
|
|
|
GstElementDetails gst_autoplugcache_details = {
|
|
"AutoplugCache",
|
|
"Connection",
|
|
"Data cache for the dynamic autoplugger",
|
|
VERSION,
|
|
"Erik Walthinsen <omega@temple-baptist.com>",
|
|
"(C) 2001 RidgeRun, Inc. (www.ridgerun.com)",
|
|
};
|
|
|
|
#define GST_TYPE_AUTOPLUGCACHE \
|
|
(gst_autoplugcache_get_type())
|
|
#define GST_AUTOPLUGCACHE(obj) \
|
|
(GTK_CHECK_CAST((obj),GST_TYPE_AUTOPLUGCACHE,GstAutoplugCache))
|
|
#define GST_AUTOPLUGCACHE_CLASS(klass) \
|
|
(GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUTOPLUGCACHE,GstAutoplugCacheClass))
|
|
#define GST_IS_AUTOPLUGCACHE(obj) \
|
|
(GTK_CHECK_TYPE((obj),GST_TYPE_AUTOPLUGCACHE))
|
|
#define GST_IS_AUTOPLUGCACHE_CLASS(obj) \
|
|
(GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUTOPLUGCACHE))
|
|
|
|
typedef struct _GstAutoplugCache GstAutoplugCache;
|
|
typedef struct _GstAutoplugCacheClass GstAutoplugCacheClass;
|
|
|
|
struct _GstAutoplugCache {
|
|
GstElement element;
|
|
|
|
GstPad *sinkpad, *srcpad;
|
|
|
|
gboolean caps_proxy;
|
|
|
|
GList *cache;
|
|
GList *cache_start;
|
|
gint buffer_count;
|
|
GList *current_playout;
|
|
gboolean fire_empty;
|
|
gboolean fire_first;
|
|
};
|
|
|
|
struct _GstAutoplugCacheClass {
|
|
GstElementClass parent_class;
|
|
|
|
void (*first_buffer) (GstElement *element, GstBuffer *buf);
|
|
void (*cache_empty) (GstElement *element);
|
|
};
|
|
|
|
|
|
/* Cache signals and args */
|
|
enum {
|
|
FIRST_BUFFER,
|
|
CACHE_EMPTY,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum {
|
|
ARG_0,
|
|
ARG_BUFFER_COUNT,
|
|
ARG_CAPS_PROXY,
|
|
ARG_RESET
|
|
};
|
|
|
|
|
|
static void gst_autoplugcache_class_init (GstAutoplugCacheClass *klass);
|
|
static void gst_autoplugcache_init (GstAutoplugCache *cache);
|
|
|
|
static void gst_autoplugcache_set_arg (GtkObject *object, GtkArg *arg, guint id);
|
|
static void gst_autoplugcache_get_arg (GtkObject *object, GtkArg *arg, guint id);
|
|
|
|
static void gst_autoplugcache_loop (GstElement *element);
|
|
|
|
static GstPadNegotiateReturn gst_autoplugcache_nego_src (GstPad *pad, GstCaps **caps, gpointer *data);
|
|
static GstPadNegotiateReturn gst_autoplugcache_nego_sink (GstPad *pad, GstCaps **caps, gpointer *data);
|
|
static GstElementStateReturn gst_autoplugcache_change_state (GstElement *element);
|
|
|
|
|
|
static GstElementClass *parent_class = NULL;
|
|
static guint gst_autoplugcache_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
GtkType
|
|
gst_autoplugcache_get_type(void) {
|
|
static GtkType autoplugcache_type = 0;
|
|
|
|
if (!autoplugcache_type) {
|
|
static const GtkTypeInfo autoplugcache_info = {
|
|
"GstAutoplugCache",
|
|
sizeof(GstAutoplugCache),
|
|
sizeof(GstAutoplugCacheClass),
|
|
(GtkClassInitFunc)gst_autoplugcache_class_init,
|
|
(GtkObjectInitFunc)gst_autoplugcache_init,
|
|
(GtkArgSetFunc)gst_autoplugcache_set_arg,
|
|
(GtkArgGetFunc)gst_autoplugcache_get_arg,
|
|
(GtkClassInitFunc)NULL,
|
|
};
|
|
autoplugcache_type = gtk_type_unique (GST_TYPE_ELEMENT, &autoplugcache_info);
|
|
}
|
|
return autoplugcache_type;
|
|
}
|
|
|
|
static void
|
|
gst_autoplugcache_class_init (GstAutoplugCacheClass *klass)
|
|
{
|
|
GtkObjectClass *gtkobject_class;
|
|
GstElementClass *gstelement_class;
|
|
|
|
gtkobject_class = (GtkObjectClass*)klass;
|
|
gstelement_class = (GstElementClass*)klass;
|
|
|
|
parent_class = gtk_type_class (GST_TYPE_ELEMENT);
|
|
|
|
gst_autoplugcache_signals[FIRST_BUFFER] =
|
|
gtk_signal_new ("first_buffer", GTK_RUN_LAST, gtkobject_class->type,
|
|
GTK_SIGNAL_OFFSET (GstAutoplugCacheClass, first_buffer),
|
|
gtk_marshal_NONE__POINTER, GTK_TYPE_NONE, 1,
|
|
GTK_TYPE_POINTER);
|
|
gst_autoplugcache_signals[CACHE_EMPTY] =
|
|
gtk_signal_new ("cache_empty", GTK_RUN_LAST, gtkobject_class->type,
|
|
GTK_SIGNAL_OFFSET (GstAutoplugCacheClass, cache_empty),
|
|
gtk_marshal_NONE__NONE, GTK_TYPE_NONE, 0);
|
|
gtk_object_class_add_signals (gtkobject_class, gst_autoplugcache_signals, LAST_SIGNAL);
|
|
|
|
gtk_object_add_arg_type ("GstAutoplugCache::buffer_count", GTK_TYPE_INT,
|
|
GTK_ARG_READABLE, ARG_BUFFER_COUNT);
|
|
gtk_object_add_arg_type ("GstAutoplugCache::caps_proxy", GTK_TYPE_BOOL,
|
|
GTK_ARG_READWRITE, ARG_CAPS_PROXY);
|
|
gtk_object_add_arg_type ("GstAutoplugCache::reset", GTK_TYPE_BOOL,
|
|
GTK_ARG_WRITABLE, ARG_RESET);
|
|
|
|
gtkobject_class->set_arg = gst_autoplugcache_set_arg;
|
|
gtkobject_class->get_arg = gst_autoplugcache_get_arg;
|
|
|
|
gstelement_class->change_state = gst_autoplugcache_change_state;
|
|
}
|
|
|
|
static void
|
|
gst_autoplugcache_init (GstAutoplugCache *cache)
|
|
{
|
|
gst_element_set_loop_function(GST_ELEMENT(cache), GST_DEBUG_FUNCPTR(gst_autoplugcache_loop));
|
|
|
|
cache->sinkpad = gst_pad_new ("sink", GST_PAD_SINK);
|
|
// gst_pad_set_negotiate_function (cache->sinkpad, gst_autoplugcache_nego_sink);
|
|
gst_element_add_pad (GST_ELEMENT(cache), cache->sinkpad);
|
|
|
|
cache->srcpad = gst_pad_new ("src", GST_PAD_SRC);
|
|
// gst_pad_set_negotiate_function (cache->srcpad, gst_autoplugcache_nego_src);
|
|
gst_element_add_pad (GST_ELEMENT(cache), cache->srcpad);
|
|
|
|
cache->caps_proxy = FALSE;
|
|
|
|
// provide a zero basis for the cache
|
|
cache->cache = g_list_prepend(NULL, NULL);
|
|
cache->cache_start = cache->cache;
|
|
cache->buffer_count = 0;
|
|
cache->current_playout = 0;
|
|
cache->fire_empty = FALSE;
|
|
cache->fire_first = FALSE;
|
|
}
|
|
|
|
static void
|
|
gst_autoplugcache_loop (GstElement *element)
|
|
{
|
|
GstAutoplugCache *cache;
|
|
GstBuffer *buf = NULL;
|
|
|
|
cache = GST_AUTOPLUGCACHE (element);
|
|
|
|
/* Theory:
|
|
* The cache is a doubly-linked list. The front of the list is the most recent
|
|
* buffer, the end of the list is the first buffer. The playout pointer always
|
|
* points to the latest buffer sent out the end. cache points to the front
|
|
* (most reccent) of the list at all times. cache_start points to the first
|
|
* buffer, i.e. the end of the list.
|
|
* If the playout pointer does not have a prev (towards the most recent) buffer
|
|
* (== NULL), a buffer must be pulled from the sink pad and added to the cache.
|
|
* When the playout pointer gets reset (as in a set_arg), the cache is walked
|
|
* without problems, because the playout pointer has a non-NULL next. When
|
|
* the playout pointer hits the end of cache again it has to start pulling.
|
|
*/
|
|
|
|
do {
|
|
// the first time through, the current_playout pointer is going to be NULL
|
|
if (cache->current_playout == NULL) {
|
|
// get a buffer
|
|
buf = gst_pad_pull (cache->sinkpad);
|
|
|
|
// add it to the cache, though cache == NULL
|
|
gst_buffer_ref (buf);
|
|
cache->cache = g_list_prepend (cache->cache, buf);
|
|
cache->buffer_count++;
|
|
|
|
// set the current_playout pointer
|
|
cache->current_playout = cache->cache;
|
|
|
|
gtk_signal_emit (GTK_OBJECT(cache), gst_autoplugcache_signals[FIRST_BUFFER], buf);
|
|
|
|
// send the buffer on its way
|
|
gst_pad_push (cache->srcpad, buf);
|
|
}
|
|
|
|
// the steady state is where the playout is at the front of the cache
|
|
else if (g_list_previous(cache->current_playout) == NULL) {
|
|
|
|
// if we've been told to fire an empty signal (after a reset)
|
|
if (cache->fire_empty) {
|
|
int oldstate = GST_STATE(cache);
|
|
fprintf(stderr,"at front of cache, about to pull, but firing signal\n");
|
|
gst_object_ref (GST_OBJECT (cache));
|
|
gtk_signal_emit (GTK_OBJECT(cache), gst_autoplugcache_signals[CACHE_EMPTY], NULL);
|
|
if (GST_STATE(cache) != oldstate) {
|
|
gst_object_ref (GST_OBJECT (cache));
|
|
GST_DEBUG(GST_CAT_AUTOPLUG, "state changed during signal, aborting\n");
|
|
cothread_switch(cothread_current_main());
|
|
}
|
|
gst_object_unref (GST_OBJECT (cache));
|
|
}
|
|
|
|
// get a buffer
|
|
buf = gst_pad_pull (cache->sinkpad);
|
|
|
|
// add it to the front of the cache
|
|
gst_buffer_ref (buf);
|
|
cache->cache = g_list_prepend (cache->cache, buf);
|
|
cache->buffer_count++;
|
|
|
|
// set the current_playout pointer
|
|
cache->current_playout = cache->cache;
|
|
|
|
// send the buffer on its way
|
|
gst_pad_push (cache->srcpad, buf);
|
|
}
|
|
|
|
// otherwise we're trundling through existing cached buffers
|
|
else {
|
|
// move the current_playout pointer
|
|
cache->current_playout = g_list_previous (cache->current_playout);
|
|
|
|
if (cache->fire_first) {
|
|
gtk_signal_emit (GTK_OBJECT(cache), gst_autoplugcache_signals[FIRST_BUFFER], buf);
|
|
cache->fire_first = FALSE;
|
|
}
|
|
|
|
// push that buffer
|
|
gst_pad_push (cache->srcpad, GST_BUFFER(cache->current_playout->data));
|
|
}
|
|
} while (!GST_FLAG_IS_SET (element, GST_ELEMENT_COTHREAD_STOPPING));
|
|
}
|
|
|
|
static GstPadNegotiateReturn
|
|
gst_autoplugcache_nego_src (GstPad *pad, GstCaps **caps, gpointer *data)
|
|
{
|
|
GstAutoplugCache *cache = GST_AUTOPLUGCACHE (GST_PAD_PARENT (pad));
|
|
|
|
return gst_pad_negotiate_proxy (pad, cache->sinkpad, caps);
|
|
}
|
|
|
|
static GstPadNegotiateReturn
|
|
gst_autoplugcache_nego_sink (GstPad *pad, GstCaps **caps, gpointer *data)
|
|
{
|
|
GstAutoplugCache *cache = GST_AUTOPLUGCACHE (GST_PAD_PARENT (pad));
|
|
|
|
return gst_pad_negotiate_proxy (pad, cache->srcpad, caps);
|
|
}
|
|
|
|
|
|
static GstElementStateReturn
|
|
gst_autoplugcache_change_state (GstElement *element)
|
|
{
|
|
// FIXME this should do something like free the cache on ->NULL
|
|
if (GST_ELEMENT_CLASS (parent_class)->change_state)
|
|
return GST_ELEMENT_CLASS (parent_class)->change_state (element);
|
|
|
|
return GST_STATE_SUCCESS;
|
|
}
|
|
|
|
static void
|
|
gst_autoplugcache_set_arg (GtkObject *object, GtkArg *arg, guint id)
|
|
{
|
|
GstAutoplugCache *cache;
|
|
|
|
cache = GST_AUTOPLUGCACHE (object);
|
|
|
|
switch (id) {
|
|
case ARG_CAPS_PROXY:
|
|
cache->caps_proxy = GTK_VALUE_BOOL(*arg);
|
|
GST_DEBUG(0,"caps_proxy is %d\n",cache->caps_proxy);
|
|
if (cache->caps_proxy) {
|
|
gst_pad_set_negotiate_function (cache->sinkpad, GST_DEBUG_FUNCPTR(gst_autoplugcache_nego_sink));
|
|
gst_pad_set_negotiate_function (cache->srcpad, GST_DEBUG_FUNCPTR(gst_autoplugcache_nego_src));
|
|
} else {
|
|
gst_pad_set_negotiate_function (cache->sinkpad, NULL);
|
|
gst_pad_set_negotiate_function (cache->srcpad, NULL);
|
|
}
|
|
break;
|
|
case ARG_RESET:
|
|
// no idea why anyone would set this to FALSE, but just in case ;-)
|
|
if (GTK_VALUE_BOOL(*arg)) {
|
|
fprintf(stderr,"resetting playout pointer\n");
|
|
// reset the playout pointer to the begining again
|
|
cache->current_playout = cache->cache_start;
|
|
// now we can fire a signal when the cache runs dry
|
|
cache->fire_empty = TRUE;
|
|
// also set it up to fire the first_buffer signal again
|
|
cache->fire_first = TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_autoplugcache_get_arg (GtkObject *object, GtkArg *arg, guint id)
|
|
{
|
|
GstAutoplugCache *cache;
|
|
|
|
cache = GST_AUTOPLUGCACHE (object);
|
|
|
|
switch (id) {
|
|
case ARG_BUFFER_COUNT:
|
|
GTK_VALUE_INT(*arg) = cache->buffer_count;
|
|
break;
|
|
case ARG_CAPS_PROXY:
|
|
GTK_VALUE_BOOL(*arg) = cache->caps_proxy;
|
|
default:
|
|
arg->type = GTK_TYPE_INVALID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
plugin_init (GModule *module, GstPlugin *plugin)
|
|
{
|
|
GstElementFactory *factory;
|
|
|
|
factory = gst_elementfactory_new ("autoplugcache", GST_TYPE_AUTOPLUGCACHE,
|
|
&gst_autoplugcache_details);
|
|
g_return_val_if_fail (factory != NULL, FALSE);
|
|
|
|
gst_plugin_add_factory (plugin, factory);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GstPluginDesc plugin_desc = {
|
|
GST_VERSION_MAJOR,
|
|
GST_VERSION_MINOR,
|
|
"autoplugcache",
|
|
plugin_init
|
|
};
|
|
|