2000-12-28 22:12:02 +00:00
|
|
|
/* GStreamer
|
|
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
|
|
*
|
|
|
|
* gstpad.c: Pads for connecting elements together
|
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.
|
|
|
|
*/
|
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* #define GST_DEBUG_ENABLED */
|
2000-12-28 21:12:40 +00:00
|
|
|
#include "gst_private.h"
|
|
|
|
|
2000-12-15 01:57:34 +00:00
|
|
|
#include "gstpad.h"
|
2001-09-17 23:44:58 +00:00
|
|
|
#include "gstutils.h"
|
2000-12-15 01:57:34 +00:00
|
|
|
#include "gstelement.h"
|
|
|
|
#include "gsttype.h"
|
2001-01-29 00:06:02 +00:00
|
|
|
#include "gstbin.h"
|
2001-05-25 21:00:07 +00:00
|
|
|
#include "gstscheduler.h"
|
2001-12-18 19:03:07 +00:00
|
|
|
#include "gstevent.h"
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-10-17 10:21:27 +00:00
|
|
|
GType _gst_pad_type = 0;
|
2000-12-28 21:12:40 +00:00
|
|
|
|
2001-01-19 02:23:35 +00:00
|
|
|
/***** Start with the base GstPad class *****/
|
2001-01-29 00:06:02 +00:00
|
|
|
static void gst_pad_class_init (GstPadClass *klass);
|
|
|
|
static void gst_pad_init (GstPad *pad);
|
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2001-01-29 00:06:02 +00:00
|
|
|
static xmlNodePtr gst_pad_save_thyself (GstObject *object, xmlNodePtr parent);
|
2001-06-24 21:18:28 +00:00
|
|
|
#endif
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2000-12-28 00:18:26 +00:00
|
|
|
static GstObject *pad_parent_class = NULL;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
GType
|
2001-10-17 10:21:27 +00:00
|
|
|
gst_pad_get_type(void)
|
|
|
|
{
|
|
|
|
if (!_gst_pad_type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
static const GTypeInfo pad_info = {
|
2000-01-30 09:03:00 +00:00
|
|
|
sizeof(GstPadClass),
|
2001-06-25 01:20:11 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc)gst_pad_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
sizeof(GstPad),
|
|
|
|
32,
|
|
|
|
(GInstanceInitFunc)gst_pad_init,
|
2001-09-14 22:16:47 +00:00
|
|
|
NULL
|
2000-01-30 09:03:00 +00:00
|
|
|
};
|
2001-10-17 10:21:27 +00:00
|
|
|
_gst_pad_type = g_type_register_static(GST_TYPE_OBJECT, "GstPad", &pad_info, 0);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-10-17 10:21:27 +00:00
|
|
|
return _gst_pad_type;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-01-19 02:23:35 +00:00
|
|
|
gst_pad_class_init (GstPadClass *klass)
|
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
pad_parent_class = g_type_class_ref(GST_TYPE_OBJECT);
|
2001-01-19 02:23:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_pad_init (GstPad *pad)
|
|
|
|
{
|
|
|
|
pad->element_private = NULL;
|
|
|
|
|
|
|
|
pad->padtemplate = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***** Then do the Real Pad *****/
|
2001-01-19 09:37:32 +00:00
|
|
|
/* Pad signals and args */
|
|
|
|
enum {
|
|
|
|
REAL_SET_ACTIVE,
|
|
|
|
REAL_CAPS_CHANGED,
|
2001-05-25 21:00:07 +00:00
|
|
|
REAL_CAPS_NEGO_FAILED,
|
|
|
|
REAL_CONNECTED,
|
|
|
|
REAL_DISCONNECTED,
|
2001-01-19 09:37:32 +00:00
|
|
|
/* FILL ME */
|
|
|
|
REAL_LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
REAL_ARG_0,
|
|
|
|
REAL_ARG_ACTIVE,
|
|
|
|
/* FILL ME */
|
|
|
|
};
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
static void gst_real_pad_class_init (GstRealPadClass *klass);
|
|
|
|
static void gst_real_pad_init (GstRealPad *pad);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
static void gst_real_pad_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
|
|
|
|
static void gst_real_pad_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-09-28 19:16:02 +00:00
|
|
|
static void gst_real_pad_dispose (GObject *object);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
static void gst_pad_push_func (GstPad *pad, GstBuffer *buf);
|
2001-01-21 23:20:46 +00:00
|
|
|
|
2001-10-17 10:21:27 +00:00
|
|
|
GType _gst_real_pad_type = 0;
|
2001-01-19 02:23:35 +00:00
|
|
|
|
|
|
|
static GstPad *real_pad_parent_class = NULL;
|
2001-01-19 09:37:32 +00:00
|
|
|
static guint gst_real_pad_signals[REAL_LAST_SIGNAL] = { 0 };
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
GType
|
2001-01-19 02:23:35 +00:00
|
|
|
gst_real_pad_get_type(void) {
|
2001-10-17 10:21:27 +00:00
|
|
|
if (!_gst_real_pad_type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
static const GTypeInfo pad_info = {
|
2001-01-19 02:23:35 +00:00
|
|
|
sizeof(GstRealPadClass),
|
2001-06-25 01:20:11 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc)gst_real_pad_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
sizeof(GstRealPad),
|
|
|
|
32,
|
|
|
|
(GInstanceInitFunc)gst_real_pad_init,
|
2001-09-14 22:16:47 +00:00
|
|
|
NULL
|
2001-01-19 02:23:35 +00:00
|
|
|
};
|
2001-10-17 10:21:27 +00:00
|
|
|
_gst_real_pad_type = g_type_register_static(GST_TYPE_PAD, "GstRealPad", &pad_info, 0);
|
2001-01-19 02:23:35 +00:00
|
|
|
}
|
2001-10-17 10:21:27 +00:00
|
|
|
return _gst_real_pad_type;
|
2001-01-19 02:23:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-01-21 23:20:46 +00:00
|
|
|
gst_real_pad_class_init (GstRealPadClass *klass)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GObjectClass *gobject_class;
|
2001-01-29 00:06:02 +00:00
|
|
|
GstObjectClass *gstobject_class;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class = (GObjectClass*)klass;
|
2001-01-29 00:06:02 +00:00
|
|
|
gstobject_class = (GstObjectClass*)klass;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
real_pad_parent_class = g_type_class_ref(GST_TYPE_PAD);
|
|
|
|
|
2001-09-28 19:16:02 +00:00
|
|
|
gobject_class->dispose = GST_DEBUG_FUNCPTR(gst_real_pad_dispose);
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class->set_property = GST_DEBUG_FUNCPTR(gst_real_pad_set_property);
|
|
|
|
gobject_class->get_property = GST_DEBUG_FUNCPTR(gst_real_pad_get_property);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
gst_real_pad_signals[REAL_SET_ACTIVE] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("set_active", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstRealPadClass, set_active), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_TYPE_BOOLEAN);
|
2001-01-19 09:37:32 +00:00
|
|
|
gst_real_pad_signals[REAL_CAPS_CHANGED] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("caps_changed", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstRealPadClass, caps_changed), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_TYPE_POINTER);
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_real_pad_signals[REAL_CAPS_NEGO_FAILED] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("caps_nego_failed", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstRealPadClass, caps_nego_failed), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_TYPE_POINTER);
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_real_pad_signals[REAL_CONNECTED] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("connected", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstRealPadClass, connected), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_TYPE_POINTER);
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_real_pad_signals[REAL_DISCONNECTED] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("disconnected", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstRealPadClass, disconnected), NULL, NULL,
|
2001-09-10 19:00:42 +00:00
|
|
|
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_TYPE_POINTER);
|
2000-11-25 07:02:55 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* gtk_object_add_arg_type ("GstRealPad::active", G_TYPE_BOOLEAN, */
|
|
|
|
/* GTK_ARG_READWRITE, REAL_ARG_ACTIVE); */
|
2001-06-25 01:20:11 +00:00
|
|
|
g_object_class_install_property (G_OBJECT_CLASS(klass), REAL_ARG_ACTIVE,
|
|
|
|
g_param_spec_boolean("active","Active","Whether the pad is active.",
|
|
|
|
TRUE,G_PARAM_READWRITE));
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2001-05-25 21:00:07 +00:00
|
|
|
gstobject_class->save_thyself = GST_DEBUG_FUNCPTR(gst_pad_save_thyself);
|
2001-06-24 21:18:28 +00:00
|
|
|
#endif
|
2001-01-29 00:06:02 +00:00
|
|
|
gstobject_class->path_string_separator = ".";
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-01-21 23:20:46 +00:00
|
|
|
static void
|
|
|
|
gst_real_pad_init (GstRealPad *pad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
pad->direction = GST_PAD_UNKNOWN;
|
|
|
|
pad->peer = NULL;
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
|
2001-12-22 21:18:17 +00:00
|
|
|
pad->sched = NULL;
|
|
|
|
pad->sched_private = NULL;
|
|
|
|
|
2000-07-17 17:14:15 +00:00
|
|
|
pad->chainfunc = NULL;
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
pad->getfunc = NULL;
|
|
|
|
pad->getregionfunc = NULL;
|
|
|
|
|
2001-08-06 20:37:21 +00:00
|
|
|
pad->chainhandler = GST_DEBUG_FUNCPTR(gst_pad_push_func);
|
|
|
|
pad->gethandler = NULL;
|
2000-11-06 00:15:51 +00:00
|
|
|
pad->pullregionfunc = NULL;
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
|
2001-04-16 21:45:02 +00:00
|
|
|
pad->bufferpoolfunc = NULL;
|
2001-01-20 02:57:46 +00:00
|
|
|
pad->ghostpads = NULL;
|
2000-12-11 00:04:25 +00:00
|
|
|
pad->caps = NULL;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-11-25 07:02:55 +00:00
|
|
|
static void
|
2001-06-25 01:20:11 +00:00
|
|
|
gst_real_pad_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
|
2001-01-19 02:23:35 +00:00
|
|
|
{
|
2000-11-25 07:02:55 +00:00
|
|
|
g_return_if_fail(GST_IS_PAD(object));
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
switch (prop_id) {
|
2001-01-19 09:37:32 +00:00
|
|
|
case REAL_ARG_ACTIVE:
|
2001-06-25 01:20:11 +00:00
|
|
|
if (g_value_get_boolean(value)) {
|
|
|
|
GST_DEBUG(GST_CAT_PADS,"activating pad %s:%s\n",GST_DEBUG_PAD_NAME(object));
|
2000-11-25 07:02:55 +00:00
|
|
|
GST_FLAG_UNSET(object,GST_PAD_DISABLED);
|
|
|
|
} else {
|
2001-06-25 01:20:11 +00:00
|
|
|
GST_DEBUG(GST_CAT_PADS,"de-activating pad %s:%s\n",GST_DEBUG_PAD_NAME(object));
|
2000-11-25 07:02:55 +00:00
|
|
|
GST_FLAG_SET(object,GST_PAD_DISABLED);
|
|
|
|
}
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit(G_OBJECT(object), gst_real_pad_signals[REAL_SET_ACTIVE], 0,
|
2000-11-25 07:02:55 +00:00
|
|
|
! GST_FLAG_IS_SET(object,GST_PAD_DISABLED));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-06-25 01:20:11 +00:00
|
|
|
gst_real_pad_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
|
2000-11-25 07:02:55 +00:00
|
|
|
{
|
|
|
|
/* it's not null if we got it, but it might not be ours */
|
|
|
|
g_return_if_fail (GST_IS_PAD (object));
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
switch (prop_id) {
|
2001-01-19 09:37:32 +00:00
|
|
|
case REAL_ARG_ACTIVE:
|
2001-06-25 01:20:11 +00:00
|
|
|
g_value_set_boolean(value, ! GST_FLAG_IS_SET (object, GST_PAD_DISABLED) );
|
2000-11-25 07:02:55 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_new:
|
|
|
|
* @name: name of new pad
|
|
|
|
* @direction: either GST_PAD_SRC or GST_PAD_SINK
|
|
|
|
*
|
|
|
|
* Create a new pad with given name.
|
|
|
|
*
|
|
|
|
* Returns: new pad
|
|
|
|
*/
|
2000-11-01 13:49:41 +00:00
|
|
|
GstPad*
|
|
|
|
gst_pad_new (gchar *name,
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPadDirection direction)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-01-19 09:37:32 +00:00
|
|
|
GstRealPad *pad;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-11-01 13:49:41 +00:00
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
g_return_val_if_fail (direction != GST_PAD_UNKNOWN, NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
pad = g_object_new (gst_real_pad_get_type (), NULL);
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_object_set_name (GST_OBJECT (pad), name);
|
2001-01-19 09:37:32 +00:00
|
|
|
GST_RPAD_DIRECTION(pad) = direction;
|
2000-12-13 19:29:35 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
return GST_PAD(pad);
|
2000-12-13 19:29:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_pad_new_from_template:
|
2001-01-19 22:15:21 +00:00
|
|
|
* @templ: the pad template to use
|
2000-12-13 19:29:35 +00:00
|
|
|
* @name: the name of the element
|
|
|
|
*
|
|
|
|
* Create a new pad with given name from the given template.
|
|
|
|
*
|
|
|
|
* Returns: new pad
|
|
|
|
*/
|
|
|
|
GstPad*
|
2001-01-19 02:23:35 +00:00
|
|
|
gst_pad_new_from_template (GstPadTemplate *templ,
|
2001-01-21 23:20:46 +00:00
|
|
|
gchar *name)
|
2000-12-13 19:29:35 +00:00
|
|
|
{
|
|
|
|
GstPad *pad;
|
|
|
|
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
2001-01-19 02:23:35 +00:00
|
|
|
g_return_val_if_fail (templ != NULL, NULL);
|
2000-12-13 19:29:35 +00:00
|
|
|
|
2001-01-19 02:23:35 +00:00
|
|
|
pad = gst_pad_new (name, templ->direction);
|
2001-09-29 15:39:00 +00:00
|
|
|
|
|
|
|
gst_object_ref (GST_OBJECT (templ));
|
2001-01-19 09:37:32 +00:00
|
|
|
GST_PAD_PADTEMPLATE(pad) = templ;
|
2001-09-29 15:39:00 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
return pad;
|
|
|
|
}
|
|
|
|
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_get_direction:
|
|
|
|
* @pad: the Pad to get the direction from
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Get the direction of the pad.
|
2000-03-27 19:53:43 +00:00
|
|
|
*
|
|
|
|
* Returns: the direction of the pad
|
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPadDirection
|
|
|
|
gst_pad_get_direction (GstPad *pad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, GST_PAD_UNKNOWN);
|
2001-01-19 09:37:32 +00:00
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), GST_PAD_UNKNOWN);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
return GST_PAD_DIRECTION(pad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_set_name:
|
|
|
|
* @pad: the pad to set the name of
|
|
|
|
* @name: the name of the pad
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Set the name of a pad.
|
2000-03-27 19:53:43 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
|
|
|
gst_pad_set_name (GstPad *pad,
|
|
|
|
const gchar *name)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_object_set_name (GST_OBJECT (pad), name);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-03-27 19:53:43 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_get_name:
|
|
|
|
* @pad: the pad to get the name of
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Get the name of a pad.
|
2000-03-27 19:53:43 +00:00
|
|
|
*
|
2000-11-01 13:49:41 +00:00
|
|
|
* Returns: the name of the pad, don't free.
|
2000-03-27 19:53:43 +00:00
|
|
|
*/
|
2000-11-01 13:49:41 +00:00
|
|
|
const gchar*
|
2001-01-21 23:20:46 +00:00
|
|
|
gst_pad_get_name (GstPad *pad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
return GST_OBJECT_NAME (pad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
* gst_pad_set_chain_function:
|
|
|
|
* @pad: the pad to set the chain function for
|
|
|
|
* @chain: the chain function
|
2000-10-25 19:09:53 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Set the given chain function for the pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
void gst_pad_set_chain_function (GstPad *pad,
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPadChainFunction chain)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
2001-01-19 02:23:35 +00:00
|
|
|
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
2001-01-19 09:37:32 +00:00
|
|
|
|
|
|
|
GST_RPAD_CHAINFUNC(pad) = chain;
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"chainfunc for %s:%s set to %s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(pad),GST_DEBUG_FUNCPTR_NAME(chain));
|
2000-02-26 18:55:14 +00:00
|
|
|
}
|
|
|
|
|
2000-12-06 23:04:12 +00:00
|
|
|
/**
|
2000-12-28 21:42:23 +00:00
|
|
|
* gst_pad_set_get_function:
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
* @pad: the pad to set the get function for
|
|
|
|
* @get: the get function
|
2000-12-06 23:04:12 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Set the given get function for the pad.
|
2000-12-06 23:04:12 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
gst_pad_set_get_function (GstPad *pad,
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPadGetFunction get)
|
2000-12-06 23:04:12 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
2001-01-19 02:23:35 +00:00
|
|
|
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
2000-12-06 23:04:12 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
GST_RPAD_GETFUNC(pad) = get;
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"getfunc for %s:%s set to %s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(pad),GST_DEBUG_FUNCPTR_NAME(get));
|
2000-12-06 23:04:12 +00:00
|
|
|
}
|
|
|
|
|
2001-08-06 20:37:21 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_set_event_function:
|
|
|
|
* @pad: the pad to set the event handler for
|
|
|
|
* @event: the event handler
|
|
|
|
*
|
|
|
|
* Set the given event handler for the pad.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_pad_set_event_function (GstPad *pad,
|
|
|
|
GstPadEventFunction event)
|
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
|
|
|
|
|
|
|
GST_RPAD_EVENTFUNC(pad) = event;
|
|
|
|
GST_DEBUG (GST_CAT_PADS,"eventfunc for %s:%s set to %s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(pad),GST_DEBUG_FUNCPTR_NAME(event));
|
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
* gst_pad_set_getregion_function:
|
|
|
|
* @pad: the pad to set the getregion function for
|
|
|
|
* @getregion: the getregion function
|
2000-10-25 19:09:53 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Set the given getregion function for the pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
gst_pad_set_getregion_function (GstPad *pad,
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPadGetRegionFunction getregion)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
2001-01-19 02:23:35 +00:00
|
|
|
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
GST_RPAD_GETREGIONFUNC(pad) = getregion;
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"getregionfunc for %s:%s set to %s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(pad),GST_DEBUG_FUNCPTR_NAME(getregion));
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
/**
|
2001-03-21 21:43:56 +00:00
|
|
|
* gst_pad_set_negotiate_function:
|
|
|
|
* @pad: the pad to set the negotiate function for
|
|
|
|
* @nego: the negotiate function
|
2001-03-12 21:02:12 +00:00
|
|
|
*
|
2001-03-21 21:43:56 +00:00
|
|
|
* Set the given negotiate function for the pad.
|
2001-03-12 21:02:12 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_pad_set_negotiate_function (GstPad *pad,
|
|
|
|
GstPadNegotiateFunction nego)
|
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
|
|
|
|
|
|
|
GST_RPAD_NEGOTIATEFUNC(pad) = nego;
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"negotiatefunc for %s:%s set to %s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(pad),GST_DEBUG_FUNCPTR_NAME(nego));
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_set_newcaps_function:
|
|
|
|
* @pad: the pad to set the newcaps function for
|
|
|
|
* @newcaps: the newcaps function
|
|
|
|
*
|
|
|
|
* Set the given newcaps function for the pad.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_pad_set_newcaps_function (GstPad *pad,
|
|
|
|
GstPadNewCapsFunction newcaps)
|
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
|
|
|
|
|
|
|
GST_RPAD_NEWCAPSFUNC (pad) = newcaps;
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"newcapsfunc for %s:%s set to %s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(pad),GST_DEBUG_FUNCPTR_NAME(newcaps));
|
2001-04-12 18:11:19 +00:00
|
|
|
}
|
|
|
|
|
2001-04-16 21:45:02 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_set_bufferpool_function:
|
|
|
|
* @pad: the pad to set the bufferpool function for
|
2001-04-17 21:14:55 +00:00
|
|
|
* @bufpool: the bufferpool function
|
2001-04-16 21:45:02 +00:00
|
|
|
*
|
|
|
|
* Set the given bufferpool function for the pad.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_pad_set_bufferpool_function (GstPad *pad,
|
|
|
|
GstPadBufferPoolFunction bufpool)
|
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
2001-04-12 18:11:19 +00:00
|
|
|
|
2001-04-16 21:45:02 +00:00
|
|
|
GST_RPAD_BUFFERPOOLFUNC (pad) = bufpool;
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"bufferpoolfunc for %s:%s set to %s\n",
|
|
|
|
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME(bufpool));
|
2001-04-16 21:45:02 +00:00
|
|
|
}
|
2000-12-31 22:18:05 +00:00
|
|
|
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
static void
|
2001-01-21 23:20:46 +00:00
|
|
|
gst_pad_push_func(GstPad *pad, GstBuffer *buf)
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
{
|
2001-01-19 09:37:32 +00:00
|
|
|
if (GST_RPAD_CHAINFUNC(GST_RPAD_PEER(pad)) != NULL) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_DATAFLOW,"calling chain function %s\n",
|
|
|
|
GST_DEBUG_FUNCPTR_NAME(GST_RPAD_CHAINFUNC(GST_RPAD_PEER(pad))));
|
2001-01-19 09:37:32 +00:00
|
|
|
(GST_RPAD_CHAINFUNC(GST_RPAD_PEER(pad)))(pad,buf);
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
} else {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_DATAFLOW,"got a problem here: default pad_push handler in place, no chain function\n");
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-07-17 17:14:15 +00:00
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_disconnect:
|
|
|
|
* @srcpad: the source pad to disconnect
|
|
|
|
* @sinkpad: the sink pad to disconnect
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Disconnects the source pad from the sink pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
2000-11-01 13:49:41 +00:00
|
|
|
gst_pad_disconnect (GstPad *srcpad,
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPad *sinkpad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-01-19 02:23:35 +00:00
|
|
|
GstRealPad *realsrc, *realsink;
|
|
|
|
|
2000-06-25 21:38:00 +00:00
|
|
|
/* generic checks */
|
2000-11-01 13:49:41 +00:00
|
|
|
g_return_if_fail (srcpad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (srcpad));
|
|
|
|
g_return_if_fail (sinkpad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (sinkpad));
|
2000-06-25 21:38:00 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_INFO (GST_CAT_ELEMENT_PADS, "disconnecting %s:%s(%p) and %s:%s(%p)",
|
|
|
|
GST_DEBUG_PAD_NAME(srcpad), srcpad, GST_DEBUG_PAD_NAME(sinkpad), sinkpad);
|
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* now we need to deal with the real/ghost stuff */
|
2001-01-19 09:37:32 +00:00
|
|
|
realsrc = GST_PAD_REALIZE(srcpad);
|
|
|
|
realsink = GST_PAD_REALIZE(sinkpad);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
g_return_if_fail (GST_RPAD_PEER(realsrc) != NULL);
|
|
|
|
g_return_if_fail (GST_RPAD_PEER(realsink) != NULL);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
if ((GST_RPAD_DIRECTION(realsrc) == GST_PAD_SINK) &&
|
|
|
|
(GST_RPAD_DIRECTION(realsink) == GST_PAD_SRC)) {
|
|
|
|
GstRealPad *temppad;
|
|
|
|
|
|
|
|
temppad = realsrc;
|
|
|
|
realsrc = realsink;
|
|
|
|
realsink = temppad;
|
|
|
|
}
|
2001-01-19 09:37:32 +00:00
|
|
|
g_return_if_fail ((GST_RPAD_DIRECTION(realsrc) == GST_PAD_SRC) &&
|
|
|
|
(GST_RPAD_DIRECTION(realsink) == GST_PAD_SINK));
|
2000-06-25 21:38:00 +00:00
|
|
|
|
|
|
|
/* first clear peers */
|
2001-01-19 09:37:32 +00:00
|
|
|
GST_RPAD_PEER(realsrc) = NULL;
|
|
|
|
GST_RPAD_PEER(realsink) = NULL;
|
2000-06-25 21:38:00 +00:00
|
|
|
|
2001-12-19 19:22:53 +00:00
|
|
|
/* now tell the scheduler */
|
|
|
|
if (GST_PAD_PARENT (realsrc)->sched)
|
|
|
|
gst_scheduler_pad_disconnect (GST_PAD_PARENT (realsrc)->sched, (GstPad *)realsrc, (GstPad *)realsink);
|
|
|
|
else if (GST_PAD_PARENT (realsink)->sched)
|
|
|
|
gst_scheduler_pad_disconnect (GST_PAD_PARENT (realsink)->sched, (GstPad *)realsrc, (GstPad *)realsink);
|
2001-12-15 22:37:35 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
/* fire off a signal to each of the pads telling them that they've been disconnected */
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit(G_OBJECT(realsrc), gst_real_pad_signals[REAL_DISCONNECTED], 0, realsink);
|
|
|
|
g_signal_emit(G_OBJECT(realsink), gst_real_pad_signals[REAL_DISCONNECTED], 0, realsrc);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-01-01 08:37:41 +00:00
|
|
|
GST_INFO (GST_CAT_ELEMENT_PADS, "disconnected %s:%s and %s:%s",
|
|
|
|
GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
|
2000-06-25 21:38:00 +00:00
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_connect:
|
|
|
|
* @srcpad: the source pad to connect
|
|
|
|
* @sinkpad: the sink pad to connect
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Connects the source pad to the sink pad.
|
2001-09-17 23:44:58 +00:00
|
|
|
*
|
|
|
|
* You shouldn't use this API in a real application because the
|
2001-09-17 23:56:30 +00:00
|
|
|
* failure mode dumps diagnostics to stderr. A professional
|
|
|
|
* application should never fail, or use gst_pad_try_connect and
|
|
|
|
* check the return code.
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
2001-09-14 19:45:20 +00:00
|
|
|
void
|
2000-11-01 13:49:41 +00:00
|
|
|
gst_pad_connect (GstPad *srcpad,
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPad *sinkpad)
|
2001-09-14 19:45:20 +00:00
|
|
|
{
|
2001-12-22 21:18:17 +00:00
|
|
|
if (!gst_pad_try_connect (srcpad, sinkpad)) {
|
2001-09-23 08:26:10 +00:00
|
|
|
g_warning ("couldn't connect %s:%s and %s:%s",
|
2001-09-17 23:56:30 +00:00
|
|
|
GST_DEBUG_PAD_NAME (srcpad),
|
|
|
|
GST_DEBUG_PAD_NAME (sinkpad));
|
2001-12-22 21:18:17 +00:00
|
|
|
}
|
2001-09-14 19:45:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_pad_try_connect:
|
|
|
|
* @srcpad: the source pad to connect
|
|
|
|
* @sinkpad: the sink pad to connect
|
|
|
|
*
|
|
|
|
* Connects the source pad to the sink pad.
|
|
|
|
*
|
|
|
|
* Returns: TRUE if the pad could be connected
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_pad_try_connect (GstPad *srcpad,
|
|
|
|
GstPad *sinkpad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-01-19 02:23:35 +00:00
|
|
|
GstRealPad *realsrc, *realsink;
|
2001-03-12 21:02:12 +00:00
|
|
|
gboolean negotiated = FALSE;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* generic checks */
|
2001-03-12 21:02:12 +00:00
|
|
|
g_return_val_if_fail(srcpad != NULL, FALSE);
|
|
|
|
g_return_val_if_fail(GST_IS_PAD(srcpad), FALSE);
|
|
|
|
g_return_val_if_fail(sinkpad != NULL, FALSE);
|
|
|
|
g_return_val_if_fail(GST_IS_PAD(sinkpad), FALSE);
|
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_INFO (GST_CAT_PADS, "connecting %s:%s and %s:%s",
|
2001-03-12 21:02:12 +00:00
|
|
|
GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* now we need to deal with the real/ghost stuff */
|
2001-01-19 09:37:32 +00:00
|
|
|
realsrc = GST_PAD_REALIZE(srcpad);
|
|
|
|
realsink = GST_PAD_REALIZE(sinkpad);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
if ((GST_PAD (realsrc) != srcpad) || (GST_PAD (realsink) != sinkpad))
|
|
|
|
GST_INFO (GST_CAT_PADS, "*actually* connecting %s:%s and %s:%s",
|
|
|
|
GST_DEBUG_PAD_NAME(realsrc), GST_DEBUG_PAD_NAME(realsink));
|
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
g_return_val_if_fail(GST_RPAD_PEER(realsrc) == NULL, FALSE);
|
|
|
|
g_return_val_if_fail(GST_RPAD_PEER(realsink) == NULL, FALSE);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/* check for reversed directions and swap if necessary */
|
2001-01-19 09:37:32 +00:00
|
|
|
if ((GST_RPAD_DIRECTION(realsrc) == GST_PAD_SINK) &&
|
|
|
|
(GST_RPAD_DIRECTION(realsink) == GST_PAD_SRC)) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GstRealPad *temppad;
|
|
|
|
|
2001-01-19 02:23:35 +00:00
|
|
|
temppad = realsrc;
|
|
|
|
realsrc = realsink;
|
|
|
|
realsink = temppad;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-03-12 21:02:12 +00:00
|
|
|
g_return_val_if_fail((GST_RPAD_DIRECTION(realsrc) == GST_PAD_SRC) &&
|
2001-05-25 21:00:07 +00:00
|
|
|
(GST_RPAD_DIRECTION(realsink) == GST_PAD_SINK), FALSE);
|
2001-01-21 23:20:46 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
|
|
|
|
/* first set peers */
|
2001-01-19 09:37:32 +00:00
|
|
|
GST_RPAD_PEER(realsrc) = realsink;
|
|
|
|
GST_RPAD_PEER(realsink) = realsrc;
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
if (GST_PAD_CAPS (srcpad)) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_PADS, "renegotiation from srcpad\n");
|
2001-03-12 21:02:12 +00:00
|
|
|
negotiated = gst_pad_renegotiate (srcpad);
|
|
|
|
}
|
2001-03-18 02:42:30 +00:00
|
|
|
else if (GST_PAD_CAPS (sinkpad)) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_PADS, "renegotiation from sinkpad\n");
|
2001-03-12 21:02:12 +00:00
|
|
|
negotiated = gst_pad_renegotiate (sinkpad);
|
|
|
|
}
|
2001-05-25 21:00:07 +00:00
|
|
|
else {
|
|
|
|
GST_DEBUG(GST_CAT_PADS, "not renegotiating connection\n");
|
2001-03-18 02:42:30 +00:00
|
|
|
negotiated = TRUE;
|
2001-05-25 21:00:07 +00:00
|
|
|
}
|
2001-03-12 21:02:12 +00:00
|
|
|
|
|
|
|
if (!negotiated) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_INFO(GST_CAT_PADS, "pads %s:%s and %s:%s failed to negotiate, disconnecting",
|
|
|
|
GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
|
2001-03-13 20:26:23 +00:00
|
|
|
gst_pad_disconnect (GST_PAD (realsrc), GST_PAD (realsink));
|
2001-03-12 21:02:12 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
/* fire off a signal to each of the pads telling them that they've been connected */
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit(G_OBJECT(realsrc), gst_real_pad_signals[REAL_CONNECTED], 0, realsink);
|
|
|
|
g_signal_emit(G_OBJECT(realsink), gst_real_pad_signals[REAL_CONNECTED], 0, realsrc);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* now tell the scheduler(s) */
|
2001-05-25 21:00:07 +00:00
|
|
|
if (realsrc->sched)
|
2001-12-04 22:12:50 +00:00
|
|
|
gst_scheduler_pad_connect (realsrc->sched, (GstPad *)realsrc, (GstPad *)realsink);
|
2001-05-25 21:00:07 +00:00
|
|
|
else if (realsink->sched)
|
2001-12-04 22:12:50 +00:00
|
|
|
gst_scheduler_pad_connect (realsink->sched, (GstPad *)realsrc, (GstPad *)realsink);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
GST_INFO (GST_CAT_PADS, "connected %s:%s and %s:%s",
|
|
|
|
GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
|
2001-03-12 21:02:12 +00:00
|
|
|
return TRUE;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_set_parent:
|
2001-01-21 23:20:46 +00:00
|
|
|
* @pad: the pad to set the parent
|
2000-10-25 19:09:53 +00:00
|
|
|
* @parent: the object to set the parent to
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Sets the parent object of a pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
2000-11-01 13:49:41 +00:00
|
|
|
gst_pad_set_parent (GstPad *pad,
|
2001-01-29 00:06:02 +00:00
|
|
|
GstObject *parent)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
2001-01-29 00:06:02 +00:00
|
|
|
g_return_if_fail (GST_PAD_PARENT (pad) == NULL);
|
2000-11-01 13:49:41 +00:00
|
|
|
g_return_if_fail (parent != NULL);
|
2001-06-25 01:20:11 +00:00
|
|
|
g_return_if_fail (GST_IS_OBJECT (parent));
|
2000-11-01 13:49:41 +00:00
|
|
|
g_return_if_fail ((gpointer)pad != (gpointer)parent);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_object_set_parent (GST_OBJECT (pad), parent);
|
|
|
|
}
|
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
/**
|
2001-05-27 14:37:29 +00:00
|
|
|
* gst_pad_get_parent:
|
|
|
|
* @pad: the pad to get the parent from
|
2001-03-12 21:02:12 +00:00
|
|
|
*
|
2001-05-27 14:37:29 +00:00
|
|
|
* Get the parent object of this pad.
|
2001-03-12 21:02:12 +00:00
|
|
|
*
|
2001-05-27 14:37:29 +00:00
|
|
|
* Returns: the parent object
|
2001-03-12 21:02:12 +00:00
|
|
|
*/
|
2001-05-27 14:37:29 +00:00
|
|
|
GstElement*
|
|
|
|
gst_pad_get_parent (GstPad *pad)
|
2001-03-12 21:02:12 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
|
|
|
|
2001-05-27 14:37:29 +00:00
|
|
|
return GST_PAD_PARENT (pad);
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
/**
|
2001-05-27 14:37:29 +00:00
|
|
|
* gst_pad_get_padtemplate:
|
|
|
|
* @pad: the pad to get the padtemplate from
|
2001-01-29 00:06:02 +00:00
|
|
|
*
|
2001-05-27 14:37:29 +00:00
|
|
|
* Get the padtemplate object of this pad.
|
2001-01-29 00:06:02 +00:00
|
|
|
*
|
2001-05-27 14:37:29 +00:00
|
|
|
* Returns: the padtemplate object
|
2001-01-29 00:06:02 +00:00
|
|
|
*/
|
2001-05-27 14:37:29 +00:00
|
|
|
GstPadTemplate*
|
|
|
|
gst_pad_get_padtemplate (GstPad *pad)
|
2001-01-29 00:06:02 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
2000-03-22 21:18:15 +00:00
|
|
|
|
2001-05-27 14:37:29 +00:00
|
|
|
return GST_PAD_PADTEMPLATE (pad);
|
2001-05-25 21:00:07 +00:00
|
|
|
}
|
|
|
|
|
2001-12-19 19:22:53 +00:00
|
|
|
|
|
|
|
/*
|
2001-05-27 14:37:29 +00:00
|
|
|
* gst_pad_set_sched:
|
|
|
|
* @pad: the pad to set the scheduler for
|
|
|
|
* @sched: The scheduler to set
|
|
|
|
*
|
|
|
|
* Set the sceduler for the pad
|
|
|
|
*/
|
2001-05-25 21:00:07 +00:00
|
|
|
void
|
2001-12-04 22:12:50 +00:00
|
|
|
gst_pad_set_sched (GstPad *pad, GstScheduler *sched)
|
2001-05-25 21:00:07 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (pad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
2001-12-19 19:22:53 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_RPAD_SCHED(pad) = sched;
|
|
|
|
}
|
2001-12-19 19:22:53 +00:00
|
|
|
|
2001-05-27 14:37:29 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_get_sched:
|
|
|
|
* @pad: the pad to get the scheduler from
|
|
|
|
*
|
|
|
|
* Get the scheduler of the pad
|
|
|
|
*
|
|
|
|
* Returns: the scheduler of the pad.
|
|
|
|
*/
|
2001-12-04 22:12:50 +00:00
|
|
|
GstScheduler*
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_pad_get_sched (GstPad *pad)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
2001-12-19 19:22:53 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
return GST_RPAD_SCHED(pad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_get_real_parent:
|
|
|
|
* @pad: the pad to get the parent from
|
|
|
|
*
|
|
|
|
* Get the real parent object of this pad. If the pad
|
|
|
|
* is a ghostpad, the actual owner of the real pad is
|
2001-05-27 14:37:29 +00:00
|
|
|
* returned, as opposed to the gst_pad_get_parent().
|
2001-03-07 21:52:56 +00:00
|
|
|
*
|
|
|
|
* Returns: the parent object
|
|
|
|
*/
|
2001-05-25 21:00:07 +00:00
|
|
|
GstElement*
|
2001-03-07 21:52:56 +00:00
|
|
|
gst_pad_get_real_parent (GstPad *pad)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
|
|
|
|
|
|
|
return GST_PAD_PARENT (GST_PAD (GST_PAD_REALIZE (pad)));
|
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
2001-01-20 02:57:46 +00:00
|
|
|
* gst_pad_add_ghost_pad:
|
2001-01-21 23:20:46 +00:00
|
|
|
* @pad: the pad to set the ghost parent
|
2001-01-20 02:57:46 +00:00
|
|
|
* @ghostpad: the ghost pad to add
|
2000-10-25 19:09:53 +00:00
|
|
|
*
|
2001-01-20 02:57:46 +00:00
|
|
|
* Add a ghost pad to a pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
2001-01-20 02:57:46 +00:00
|
|
|
gst_pad_add_ghost_pad (GstPad *pad,
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPad *ghostpad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-01-19 02:23:35 +00:00
|
|
|
GstRealPad *realpad;
|
|
|
|
|
2000-11-01 13:49:41 +00:00
|
|
|
g_return_if_fail (pad != NULL);
|
2001-01-20 02:57:46 +00:00
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
|
|
|
g_return_if_fail (ghostpad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_GHOST_PAD (ghostpad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
realpad = GST_PAD_REALIZE(pad);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-01-20 02:57:46 +00:00
|
|
|
realpad->ghostpads = g_list_prepend (realpad->ghostpads, ghostpad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
2001-01-21 23:20:46 +00:00
|
|
|
* gst_pad_remove_ghost_pad:
|
|
|
|
* @pad: the pad to remove the ghost parent
|
2001-01-20 02:57:46 +00:00
|
|
|
* @ghostpad: the ghost pad to remove from the pad
|
2000-10-25 19:09:53 +00:00
|
|
|
*
|
2001-01-20 02:57:46 +00:00
|
|
|
* Remove a ghost pad from a pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
|
|
|
gst_pad_remove_ghost_pad (GstPad *pad,
|
|
|
|
GstPad *ghostpad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-01-19 02:23:35 +00:00
|
|
|
GstRealPad *realpad;
|
|
|
|
|
2000-11-01 13:49:41 +00:00
|
|
|
g_return_if_fail (pad != NULL);
|
2001-01-20 02:57:46 +00:00
|
|
|
g_return_if_fail (GST_IS_PAD (pad));
|
|
|
|
g_return_if_fail (ghostpad != NULL);
|
|
|
|
g_return_if_fail (GST_IS_GHOST_PAD (ghostpad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
realpad = GST_PAD_REALIZE (pad);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-01-20 02:57:46 +00:00
|
|
|
realpad->ghostpads = g_list_remove (realpad->ghostpads, ghostpad);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
2001-01-20 02:57:46 +00:00
|
|
|
* gst_pad_get_ghost_pad_list:
|
2000-10-25 19:09:53 +00:00
|
|
|
* @pad: the pad to get the ghost parents from
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Get the ghost parents of this pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*
|
2001-01-20 02:57:46 +00:00
|
|
|
* Returns: a GList of ghost pads
|
2000-10-25 19:09:53 +00:00
|
|
|
*/
|
2000-11-01 13:49:41 +00:00
|
|
|
GList*
|
2001-01-21 23:20:46 +00:00
|
|
|
gst_pad_get_ghost_pad_list (GstPad *pad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
2001-01-20 02:57:46 +00:00
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-20 02:57:46 +00:00
|
|
|
return GST_PAD_REALIZE(pad)->ghostpads;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-12-08 18:24:16 +00:00
|
|
|
/**
|
2001-03-12 21:02:12 +00:00
|
|
|
* gst_pad_set_caps:
|
2000-12-08 18:24:16 +00:00
|
|
|
* @pad: the pad to set the caps to
|
2001-03-21 21:43:56 +00:00
|
|
|
* @caps: the capabilities to attach to this pad
|
2000-12-08 18:24:16 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Set the capabilities of this pad.
|
2001-03-21 21:43:56 +00:00
|
|
|
*
|
|
|
|
* Returns: a boolean indicating the caps could be set on the pad
|
2000-12-08 18:24:16 +00:00
|
|
|
*/
|
2001-03-18 02:42:30 +00:00
|
|
|
gboolean
|
2001-03-12 21:02:12 +00:00
|
|
|
gst_pad_set_caps (GstPad *pad,
|
|
|
|
GstCaps *caps)
|
2000-12-08 18:24:16 +00:00
|
|
|
{
|
2001-04-16 21:45:02 +00:00
|
|
|
GstCaps *oldcaps;
|
|
|
|
|
2001-03-18 02:42:30 +00:00
|
|
|
g_return_val_if_fail (pad != NULL, FALSE);
|
2001-12-14 22:59:21 +00:00
|
|
|
g_return_val_if_fail (GST_IS_REAL_PAD (pad), FALSE); /* NOTE this restriction */
|
2000-12-08 18:24:16 +00:00
|
|
|
|
2001-04-16 21:45:02 +00:00
|
|
|
GST_INFO (GST_CAT_CAPS, "setting caps %p on pad %s:%s",
|
|
|
|
caps, GST_DEBUG_PAD_NAME(pad));
|
|
|
|
|
2001-03-18 16:17:39 +00:00
|
|
|
if (!gst_caps_check_compatibility (caps, gst_pad_get_padtemplate_caps (pad))) {
|
|
|
|
g_warning ("pad %s:%s tried to set caps incompatible with its padtemplate\n",
|
|
|
|
GST_DEBUG_PAD_NAME (pad));
|
2001-12-15 22:37:35 +00:00
|
|
|
return FALSE;
|
2001-03-18 16:17:39 +00:00
|
|
|
}
|
|
|
|
|
2001-04-16 21:45:02 +00:00
|
|
|
oldcaps = GST_PAD_CAPS (pad);
|
2001-03-20 18:29:00 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
if (caps)
|
|
|
|
gst_caps_ref (caps);
|
2001-01-19 09:37:32 +00:00
|
|
|
GST_PAD_CAPS(pad) = caps;
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-04-16 21:45:02 +00:00
|
|
|
if (oldcaps)
|
|
|
|
gst_caps_unref (oldcaps);
|
|
|
|
|
2001-03-18 02:42:30 +00:00
|
|
|
return gst_pad_renegotiate (pad);
|
2000-12-08 18:24:16 +00:00
|
|
|
}
|
2000-12-31 17:02:47 +00:00
|
|
|
|
2000-12-08 18:24:16 +00:00
|
|
|
/**
|
2001-03-21 21:43:56 +00:00
|
|
|
* gst_pad_get_caps:
|
2000-12-08 18:24:16 +00:00
|
|
|
* @pad: the pad to get the capabilities from
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Get the capabilities of this pad.
|
2000-12-08 18:24:16 +00:00
|
|
|
*
|
2001-03-21 21:43:56 +00:00
|
|
|
* Returns: the capabilities of this pad
|
2000-12-08 18:24:16 +00:00
|
|
|
*/
|
2001-03-12 21:02:12 +00:00
|
|
|
GstCaps*
|
|
|
|
gst_pad_get_caps (GstPad *pad)
|
2000-12-08 18:24:16 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
|
|
|
|
2001-03-18 02:42:30 +00:00
|
|
|
if (GST_PAD_CAPS (pad))
|
|
|
|
return GST_PAD_CAPS (pad);
|
|
|
|
else if (GST_PAD_PADTEMPLATE (pad))
|
|
|
|
return GST_PADTEMPLATE_CAPS (GST_PAD_PADTEMPLATE (pad));
|
|
|
|
|
|
|
|
return NULL;
|
2000-12-08 18:24:16 +00:00
|
|
|
}
|
|
|
|
|
2001-03-21 21:43:56 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_get_padtemplate_caps:
|
|
|
|
* @pad: the pad to get the capabilities from
|
|
|
|
*
|
|
|
|
* Get the capabilities of this pad.
|
|
|
|
*
|
|
|
|
* Returns: a list of the capabilities of this pad
|
|
|
|
*/
|
2001-03-18 02:42:30 +00:00
|
|
|
GstCaps*
|
|
|
|
gst_pad_get_padtemplate_caps (GstPad *pad)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
|
|
|
|
|
|
|
if (GST_PAD_PADTEMPLATE (pad))
|
|
|
|
return GST_PADTEMPLATE_CAPS (GST_PAD_PADTEMPLATE (pad));
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-12-31 17:02:47 +00:00
|
|
|
/**
|
2001-03-21 21:43:56 +00:00
|
|
|
* gst_padtemplate_get_caps_by_name:
|
|
|
|
* @templ: the padtemplate to get the capabilities from
|
2000-12-31 17:02:47 +00:00
|
|
|
* @name: the name of the capability to get
|
|
|
|
*
|
2001-03-21 21:43:56 +00:00
|
|
|
* Get the capability with the given name from this padtemplate.
|
2000-12-31 17:02:47 +00:00
|
|
|
*
|
|
|
|
* Returns: a capability or NULL if not found
|
|
|
|
*/
|
2001-03-12 21:02:12 +00:00
|
|
|
GstCaps*
|
|
|
|
gst_padtemplate_get_caps_by_name (GstPadTemplate *templ, const gchar *name)
|
2000-12-31 17:02:47 +00:00
|
|
|
{
|
2001-03-12 21:02:12 +00:00
|
|
|
GstCaps *caps;
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
g_return_val_if_fail (templ != NULL, NULL);
|
2000-12-31 17:02:47 +00:00
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
caps = GST_PADTEMPLATE_CAPS (templ);
|
|
|
|
if (!caps)
|
|
|
|
return NULL;
|
2001-01-21 23:20:46 +00:00
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
return gst_caps_get_by_name (caps, name);
|
2000-12-31 17:02:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_pad_check_compatibility:
|
|
|
|
* @srcpad: the srcpad to check
|
|
|
|
* @sinkpad: the sinkpad to check against
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Check if two pads have compatible capabilities.
|
2000-12-31 17:02:47 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Returns: TRUE if they are compatible or the capabilities
|
2000-12-31 17:02:47 +00:00
|
|
|
* could not be checked
|
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
gboolean
|
|
|
|
gst_pad_check_compatibility (GstPad *srcpad, GstPad *sinkpad)
|
2000-12-31 17:02:47 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (srcpad != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
|
|
|
|
g_return_val_if_fail (sinkpad != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
|
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
if (GST_PAD_CAPS(srcpad) && GST_PAD_CAPS(sinkpad)) {
|
|
|
|
if (!gst_caps_check_compatibility (GST_PAD_CAPS(srcpad), GST_PAD_CAPS(sinkpad))) {
|
2000-12-31 17:02:47 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"could not check capabilities of pads (%s:%s) and (%s:%s) %p %p\n",
|
2001-03-12 21:02:12 +00:00
|
|
|
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad),
|
|
|
|
GST_PAD_CAPS (srcpad), GST_PAD_CAPS (sinkpad));
|
2000-12-31 17:02:47 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_get_peer:
|
|
|
|
* @pad: the pad to get the peer from
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Get the peer pad of this pad.
|
2000-10-25 19:09:53 +00:00
|
|
|
*
|
|
|
|
* Returns: the peer pad
|
|
|
|
*/
|
2000-11-01 13:49:41 +00:00
|
|
|
GstPad*
|
2001-01-21 23:20:46 +00:00
|
|
|
gst_pad_get_peer (GstPad *pad)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
return GST_PAD(GST_PAD_PEER(pad));
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2001-04-17 21:14:55 +00:00
|
|
|
/**
|
2001-04-19 22:25:04 +00:00
|
|
|
* gst_pad_get_bufferpool:
|
2001-04-17 21:14:55 +00:00
|
|
|
* @pad: the pad to get the bufferpool from
|
|
|
|
*
|
2001-04-19 22:25:04 +00:00
|
|
|
* Get the bufferpool of the peer pad of the given
|
2001-04-17 21:14:55 +00:00
|
|
|
* pad
|
|
|
|
*
|
|
|
|
* Returns: The GstBufferPool or NULL.
|
|
|
|
*/
|
2001-04-16 21:45:02 +00:00
|
|
|
GstBufferPool*
|
|
|
|
gst_pad_get_bufferpool (GstPad *pad)
|
|
|
|
{
|
|
|
|
GstRealPad *peer;
|
|
|
|
|
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
|
|
|
|
|
|
|
peer = GST_RPAD_PEER(pad);
|
|
|
|
|
|
|
|
g_return_val_if_fail (peer != NULL, NULL);
|
|
|
|
|
|
|
|
GST_DEBUG_ENTER("(%s:%s)",GST_DEBUG_PAD_NAME(pad));
|
|
|
|
|
|
|
|
if (peer->bufferpoolfunc) {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"calling bufferpoolfunc &%s (@%p) of peer pad %s:%s\n",
|
2001-04-16 21:45:02 +00:00
|
|
|
GST_DEBUG_FUNCPTR_NAME(peer->bufferpoolfunc),&peer->bufferpoolfunc,GST_DEBUG_PAD_NAME(((GstPad*)peer)));
|
|
|
|
return (peer->bufferpoolfunc)(((GstPad*)peer));
|
|
|
|
} else {
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_PADS,"no bufferpoolfunc for peer pad %s:%s at %p\n",GST_DEBUG_PAD_NAME(((GstPad*)peer)),&peer->bufferpoolfunc);
|
2001-04-16 21:45:02 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-01-21 23:20:46 +00:00
|
|
|
static void
|
2001-09-28 19:16:02 +00:00
|
|
|
gst_real_pad_dispose (GObject *object)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
|
|
|
GstPad *pad = GST_PAD (object);
|
2001-09-28 19:16:02 +00:00
|
|
|
|
|
|
|
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose %s:%s\n", GST_DEBUG_PAD_NAME(pad));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-09-28 19:16:02 +00:00
|
|
|
if (GST_PAD (pad)->padtemplate){
|
|
|
|
GST_DEBUG (GST_CAT_REFCOUNTING, "unreffing padtemplate'%s'\n",GST_OBJECT_NAME(GST_OBJECT (GST_PAD (pad)->padtemplate)));
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_object_unref (GST_OBJECT (GST_PAD (pad)->padtemplate));
|
2001-09-28 19:16:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (GST_PAD_PEER (pad)){
|
|
|
|
GST_DEBUG (GST_CAT_REFCOUNTING, "disconnecting pad '%s'\n",GST_OBJECT_NAME(GST_OBJECT (GST_PAD (GST_PAD_PEER (pad)))));
|
2001-05-25 21:00:07 +00:00
|
|
|
gst_pad_disconnect (pad, GST_PAD (GST_PAD_PEER (pad)));
|
2001-09-28 19:16:02 +00:00
|
|
|
}
|
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* FIXME we should destroy the ghostpads, because they are nothing without the real pad */
|
2001-05-25 21:00:07 +00:00
|
|
|
if (GST_REAL_PAD (pad)->ghostpads) {
|
|
|
|
GList *orig, *ghostpads;
|
|
|
|
|
|
|
|
orig = ghostpads = g_list_copy (GST_REAL_PAD (pad)->ghostpads);
|
|
|
|
|
|
|
|
while (ghostpads) {
|
|
|
|
GstPad *ghostpad = GST_PAD (ghostpads->data);
|
|
|
|
|
2001-09-28 19:16:02 +00:00
|
|
|
if (GST_IS_ELEMENT (GST_OBJECT_PARENT (ghostpad))){
|
|
|
|
GST_DEBUG (GST_CAT_REFCOUNTING, "removing ghost pad from element '%s'\n", GST_OBJECT_NAME(GST_OBJECT_PARENT (ghostpad)));
|
2001-12-19 19:22:53 +00:00
|
|
|
gst_element_remove_ghost_pad (GST_ELEMENT (GST_OBJECT_PARENT (ghostpad)), GST_PAD (ghostpad));
|
2001-09-28 19:16:02 +00:00
|
|
|
}
|
2001-05-25 21:00:07 +00:00
|
|
|
ghostpads = g_list_next (ghostpads);
|
|
|
|
}
|
|
|
|
g_list_free (orig);
|
|
|
|
g_list_free (GST_REAL_PAD(pad)->ghostpads);
|
|
|
|
}
|
2001-09-29 11:00:30 +00:00
|
|
|
|
2001-12-19 19:22:53 +00:00
|
|
|
if (GST_IS_ELEMENT (GST_OBJECT_PARENT (pad))){
|
|
|
|
GST_DEBUG (GST_CAT_REFCOUNTING, "removing pad from element '%s'\n",GST_OBJECT_NAME(GST_OBJECT (GST_ELEMENT (GST_OBJECT_PARENT (pad)))));
|
|
|
|
gst_element_remove_pad (GST_ELEMENT (GST_OBJECT_PARENT (pad)), pad);
|
|
|
|
}
|
|
|
|
|
2001-09-28 19:16:02 +00:00
|
|
|
G_OBJECT_CLASS (real_pad_parent_class)->dispose (object);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2000-09-27 19:33:10 +00:00
|
|
|
/**
|
2000-10-25 19:09:53 +00:00
|
|
|
* gst_pad_load_and_connect:
|
2001-01-29 00:06:02 +00:00
|
|
|
* @self: the XML node to read the description from
|
|
|
|
* @parent: the element that has the pad
|
2000-09-27 19:33:10 +00:00
|
|
|
*
|
|
|
|
* Read the pad definition from the XML node and connect the given pad
|
2001-01-29 00:06:02 +00:00
|
|
|
* in element to a pad of an element up in the hierarchy.
|
2000-09-27 19:33:10 +00:00
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
void
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_pad_load_and_connect (xmlNodePtr self,
|
|
|
|
GstObject *parent)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-02-15 18:42:13 +00:00
|
|
|
xmlNodePtr field = self->xmlChildrenNode;
|
2000-10-08 22:17:11 +00:00
|
|
|
GstPad *pad = NULL, *targetpad;
|
|
|
|
guchar *peer = NULL;
|
2000-09-27 19:33:10 +00:00
|
|
|
gchar **split;
|
|
|
|
GstElement *target;
|
2001-01-29 00:06:02 +00:00
|
|
|
GstObject *grandparent;
|
2000-09-27 19:33:10 +00:00
|
|
|
|
|
|
|
while (field) {
|
2001-01-29 00:06:02 +00:00
|
|
|
if (!strcmp (field->name, "name")) {
|
|
|
|
pad = gst_element_get_pad (GST_ELEMENT (parent), xmlNodeGetContent (field));
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
|
|
|
else if (!strcmp(field->name, "peer")) {
|
2001-09-13 20:12:17 +00:00
|
|
|
peer = xmlNodeGetContent (field);
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
|
|
|
field = field->next;
|
|
|
|
}
|
2001-01-29 00:06:02 +00:00
|
|
|
g_return_if_fail (pad != NULL);
|
2000-12-16 17:12:28 +00:00
|
|
|
|
|
|
|
if (peer == NULL) return;
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
split = g_strsplit (peer, ".", 2);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
g_return_if_fail (split[0] != NULL);
|
|
|
|
g_return_if_fail (split[1] != NULL);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
grandparent = gst_object_get_parent (parent);
|
|
|
|
|
|
|
|
if (grandparent && GST_IS_BIN (grandparent)) {
|
|
|
|
target = gst_bin_get_by_name_recurse_up (GST_BIN (grandparent), split[0]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
goto cleanup;
|
2000-09-27 19:33:10 +00:00
|
|
|
|
|
|
|
if (target == NULL) goto cleanup;
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
targetpad = gst_element_get_pad (target, split[1]);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2000-12-08 18:24:16 +00:00
|
|
|
if (targetpad == NULL) goto cleanup;
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_pad_connect (pad, targetpad);
|
2000-09-27 19:33:10 +00:00
|
|
|
|
|
|
|
cleanup:
|
2001-01-29 00:06:02 +00:00
|
|
|
g_strfreev (split);
|
2000-09-27 19:33:10 +00:00
|
|
|
}
|
2001-12-14 22:59:21 +00:00
|
|
|
#endif /* GST_DISABLE_LOADSAVE */
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-03-18 16:17:39 +00:00
|
|
|
static gboolean
|
2001-04-12 18:11:19 +00:00
|
|
|
gst_pad_renegotiate_func (GstPad *pad, gpointer *data1, GstPad *peerpad, gpointer *data2, GstCaps **newcaps)
|
2001-03-12 21:02:12 +00:00
|
|
|
{
|
2001-03-18 16:17:39 +00:00
|
|
|
GstRealPad *currentpad, *otherpad;
|
2001-04-12 18:11:19 +00:00
|
|
|
gpointer *currentdata, *otherdata;
|
2001-03-18 02:42:30 +00:00
|
|
|
GstPadNegotiateReturn result;
|
2001-04-12 18:11:19 +00:00
|
|
|
gint counter = 0;
|
2001-03-12 21:02:12 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (pad != NULL, FALSE);
|
|
|
|
|
|
|
|
currentpad = GST_PAD_REALIZE (pad);
|
|
|
|
otherpad = GST_REAL_PAD (peerpad);
|
2001-04-12 18:11:19 +00:00
|
|
|
currentdata = data1;
|
|
|
|
otherdata = data2;
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "negotiating pad %s:%s and %s:%s data:%p\n",
|
|
|
|
GST_DEBUG_PAD_NAME(currentpad), GST_DEBUG_PAD_NAME(otherpad), currentdata);
|
2001-03-12 21:02:12 +00:00
|
|
|
|
|
|
|
do {
|
2001-03-18 02:42:30 +00:00
|
|
|
gboolean matchtempl;
|
2001-03-29 22:32:00 +00:00
|
|
|
|
|
|
|
if (!*newcaps) {
|
|
|
|
if (otherpad->negotiatefunc) {
|
|
|
|
GstRealPad *temp;
|
2001-04-12 18:11:19 +00:00
|
|
|
gpointer *tempdata;
|
2001-03-29 22:32:00 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "requesting other caps from pad %s:%s data:%p\n",
|
|
|
|
GST_DEBUG_PAD_NAME(otherpad), otherdata);
|
|
|
|
otherpad->negotiatefunc (GST_PAD (otherpad), newcaps, otherdata);
|
2001-03-29 22:32:00 +00:00
|
|
|
|
|
|
|
temp = otherpad;
|
|
|
|
otherpad = currentpad;
|
|
|
|
currentpad = temp;
|
2001-04-12 18:11:19 +00:00
|
|
|
|
|
|
|
tempdata = otherdata;
|
|
|
|
otherdata = currentdata;
|
|
|
|
currentdata = tempdata;
|
2001-03-29 22:32:00 +00:00
|
|
|
}
|
|
|
|
}
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "checking compatibility with pad %s:%s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(otherpad));
|
2001-03-18 16:17:39 +00:00
|
|
|
matchtempl = gst_caps_check_compatibility (*newcaps, gst_pad_get_padtemplate_caps (GST_PAD (otherpad)));
|
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "caps compatibility check %s\n", (matchtempl?"ok":"fail"));
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-18 02:42:30 +00:00
|
|
|
if (matchtempl) {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "checking if other pad %s:%s can negotiate data:%p\n",
|
|
|
|
GST_DEBUG_PAD_NAME(otherpad), otherdata);
|
2001-03-18 02:42:30 +00:00
|
|
|
if (otherpad->negotiatefunc) {
|
|
|
|
GstRealPad *temp;
|
2001-04-12 18:11:19 +00:00
|
|
|
gpointer *tempdata;
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "switching pad for next phase\n");
|
2001-03-18 16:17:39 +00:00
|
|
|
|
2001-03-18 02:42:30 +00:00
|
|
|
temp = currentpad;
|
|
|
|
currentpad = otherpad;
|
|
|
|
otherpad = temp;
|
2001-04-12 18:11:19 +00:00
|
|
|
|
|
|
|
tempdata = otherdata;
|
|
|
|
otherdata = currentdata;
|
|
|
|
currentdata = tempdata;
|
2001-03-18 02:42:30 +00:00
|
|
|
}
|
2001-03-18 16:17:39 +00:00
|
|
|
else if (gst_caps_check_compatibility (*newcaps, GST_PAD_CAPS (otherpad))) {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "negotiation succeeded\n");
|
2001-03-18 16:17:39 +00:00
|
|
|
return TRUE;
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
2001-03-18 02:42:30 +00:00
|
|
|
else {
|
2001-03-18 16:17:39 +00:00
|
|
|
*newcaps = GST_PAD_CAPS (otherpad);
|
2001-03-29 22:32:00 +00:00
|
|
|
if (*newcaps) gst_caps_ref(*newcaps);
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2001-03-18 16:17:39 +00:00
|
|
|
*newcaps = GST_PAD_CAPS (otherpad);
|
2001-03-29 22:32:00 +00:00
|
|
|
if (*newcaps) gst_caps_ref(*newcaps);
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
2001-03-13 20:26:23 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
counter++;
|
2001-03-13 20:26:23 +00:00
|
|
|
|
2001-03-18 02:42:30 +00:00
|
|
|
if (currentpad->negotiatefunc) {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "calling negotiate function on pad %s:%s data: %p\n",
|
|
|
|
GST_DEBUG_PAD_NAME (currentpad), currentdata);
|
|
|
|
result = currentpad->negotiatefunc (GST_PAD (currentpad), newcaps, currentdata);
|
2001-03-18 02:42:30 +00:00
|
|
|
|
|
|
|
switch (result) {
|
|
|
|
case GST_PAD_NEGOTIATE_FAIL:
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "negotiation failed\n");
|
2001-03-18 02:42:30 +00:00
|
|
|
return FALSE;
|
|
|
|
case GST_PAD_NEGOTIATE_AGREE:
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "negotiation succeeded\n");
|
2001-03-18 16:17:39 +00:00
|
|
|
return TRUE;
|
2001-03-18 02:42:30 +00:00
|
|
|
case GST_PAD_NEGOTIATE_TRY:
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "try another option\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "invalid return\n");
|
2001-03-18 02:42:30 +00:00
|
|
|
break;
|
2001-03-13 20:26:23 +00:00
|
|
|
}
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
|
|
|
else {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "negotiation failed, no more options\n");
|
2001-03-18 02:42:30 +00:00
|
|
|
return FALSE;
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
2001-03-18 02:42:30 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
} while (counter < 100);
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-20 18:29:00 +00:00
|
|
|
g_warning ("negotiation between (%s:%s) and (%s:%s) failed: too many attempts (%d)\n",
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG_PAD_NAME(pad), GST_DEBUG_PAD_NAME(peerpad), counter);
|
2001-03-20 18:29:00 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "negotiation failed, too many attempts\n");
|
2001-03-18 16:17:39 +00:00
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_pad_renegotiate:
|
|
|
|
* @pad: the pad to perform the negotiation on
|
|
|
|
*
|
|
|
|
* Perform the negotiation process with the peer pad.
|
|
|
|
*
|
|
|
|
* Returns: TRUE if the negotiation process succeded
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_pad_renegotiate (GstPad *pad)
|
|
|
|
{
|
|
|
|
GstCaps *newcaps = NULL;
|
|
|
|
GstRealPad *peerpad, *currentpad, *otherpad;
|
|
|
|
gboolean result;
|
2001-04-12 18:11:19 +00:00
|
|
|
gpointer data1 = NULL, data2 = NULL;
|
2001-03-18 02:42:30 +00:00
|
|
|
|
2001-03-18 16:17:39 +00:00
|
|
|
g_return_val_if_fail (pad != NULL, FALSE);
|
|
|
|
|
|
|
|
peerpad = GST_PAD_PEER (pad);
|
|
|
|
|
|
|
|
currentpad = GST_PAD_REALIZE (pad);
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-18 16:17:39 +00:00
|
|
|
if (!peerpad) {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "no peer pad for pad %s:%s\n",
|
2001-03-18 16:17:39 +00:00
|
|
|
GST_DEBUG_PAD_NAME(currentpad));
|
|
|
|
return TRUE;
|
|
|
|
}
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-18 16:17:39 +00:00
|
|
|
otherpad = GST_REAL_PAD (peerpad);
|
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_INFO (GST_CAT_NEGOTIATION, "negotiating pad %s:%s and %s:%s",
|
2001-03-18 16:17:39 +00:00
|
|
|
GST_DEBUG_PAD_NAME(pad), GST_DEBUG_PAD_NAME(peerpad));
|
|
|
|
|
|
|
|
newcaps = GST_PAD_CAPS (pad);
|
2001-03-29 22:32:00 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
result = gst_pad_renegotiate_func (GST_PAD (currentpad), &data1, GST_PAD (otherpad), &data2, &newcaps);
|
2001-03-18 16:17:39 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
if (!result) {
|
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "firing caps_nego_failed signal on %s:%s and %s:%s to give it a chance to succeed\n",
|
|
|
|
GST_DEBUG_PAD_NAME(currentpad),GST_DEBUG_PAD_NAME(otherpad));
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT(currentpad),
|
|
|
|
gst_real_pad_signals[REAL_CAPS_NEGO_FAILED], 0, &result);
|
|
|
|
g_signal_emit (G_OBJECT(otherpad),
|
|
|
|
gst_real_pad_signals[REAL_CAPS_NEGO_FAILED], 0, &result);
|
2001-05-25 21:00:07 +00:00
|
|
|
if (result)
|
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "caps_nego_failed handler claims success at renego, believing\n");
|
|
|
|
}
|
|
|
|
|
2001-03-18 16:17:39 +00:00
|
|
|
if (result) {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "pads aggreed on caps :)\n");
|
2001-03-18 16:17:39 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
newcaps = GST_PAD_CAPS (pad);
|
2001-12-14 22:59:21 +00:00
|
|
|
/* g_return_val_if_fail(newcaps != NULL, FALSE); FIXME is this valid? */
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-03-18 16:17:39 +00:00
|
|
|
/* here we have some sort of aggreement of the caps */
|
2001-04-16 21:45:02 +00:00
|
|
|
GST_PAD_CAPS (currentpad) = gst_caps_ref (newcaps);
|
2001-04-12 18:11:19 +00:00
|
|
|
if (GST_RPAD_NEWCAPSFUNC (currentpad))
|
|
|
|
GST_RPAD_NEWCAPSFUNC (currentpad) (GST_PAD (currentpad), newcaps);
|
|
|
|
|
2001-04-16 21:45:02 +00:00
|
|
|
GST_PAD_CAPS (otherpad) = gst_caps_ref (newcaps);
|
2001-04-12 18:11:19 +00:00
|
|
|
if (GST_RPAD_NEWCAPSFUNC (otherpad))
|
|
|
|
GST_RPAD_NEWCAPSFUNC (otherpad) (GST_PAD (otherpad), newcaps);
|
2001-05-25 21:00:07 +00:00
|
|
|
|
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "firing caps_changed signal on %s:%s and %s:%s\n",
|
|
|
|
GST_DEBUG_PAD_NAME(currentpad),GST_DEBUG_PAD_NAME(otherpad));
|
2001-06-25 01:20:11 +00:00
|
|
|
g_signal_emit (G_OBJECT(currentpad),
|
|
|
|
gst_real_pad_signals[REAL_CAPS_CHANGED], 0, GST_PAD_CAPS(currentpad));
|
|
|
|
g_signal_emit (G_OBJECT(otherpad),
|
|
|
|
gst_real_pad_signals[REAL_CAPS_CHANGED], 0, GST_PAD_CAPS(otherpad));
|
2001-03-18 16:17:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
|
|
|
|
2001-03-21 21:43:56 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_negotiate_proxy:
|
|
|
|
* @srcpad: the pad that proxies
|
|
|
|
* @destpad: the pad to proxy the negotiation to
|
|
|
|
* @caps: the current caps
|
|
|
|
*
|
|
|
|
* Proxies the negotiation pad from srcpad to destpad. Further
|
|
|
|
* negotiation is done on the peers of both pad instead.
|
|
|
|
*
|
|
|
|
* Returns: the result of the negotiation preocess.
|
|
|
|
*/
|
2001-03-18 02:42:30 +00:00
|
|
|
GstPadNegotiateReturn
|
2001-04-12 18:11:19 +00:00
|
|
|
gst_pad_negotiate_proxy (GstPad *srcpad, GstPad *destpad, GstCaps **caps)
|
2001-03-12 21:02:12 +00:00
|
|
|
{
|
2001-03-20 18:29:00 +00:00
|
|
|
GstRealPad *srcpeer;
|
|
|
|
GstRealPad *destpeer;
|
2001-03-18 16:17:39 +00:00
|
|
|
gboolean result;
|
2001-04-12 18:11:19 +00:00
|
|
|
gpointer data1 = NULL, data2 = NULL;
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-20 18:29:00 +00:00
|
|
|
g_return_val_if_fail (srcpad != NULL, GST_PAD_NEGOTIATE_FAIL);
|
|
|
|
g_return_val_if_fail (destpad != NULL, GST_PAD_NEGOTIATE_FAIL);
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "negotiation proxied from pad (%s:%s) to pad (%s:%s)\n",
|
2001-03-20 18:29:00 +00:00
|
|
|
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-20 18:29:00 +00:00
|
|
|
srcpeer = GST_RPAD_PEER (srcpad);
|
|
|
|
destpeer = GST_RPAD_PEER (destpad);
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-20 18:29:00 +00:00
|
|
|
if (srcpeer && destpeer) {
|
2001-04-12 18:11:19 +00:00
|
|
|
result = gst_pad_renegotiate_func (GST_PAD (srcpeer), &data1, GST_PAD (destpeer), &data2, caps);
|
2001-03-18 16:17:39 +00:00
|
|
|
|
|
|
|
if (result) {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "pads (%s:%s) and (%s:%s) aggreed on caps :)\n",
|
|
|
|
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
|
2001-03-18 16:17:39 +00:00
|
|
|
|
|
|
|
/* here we have some sort of aggreement of the caps */
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_PAD_CAPS (destpeer) = *caps;
|
|
|
|
if (GST_RPAD_NEWCAPSFUNC (destpeer))
|
|
|
|
GST_RPAD_NEWCAPSFUNC (destpeer) (GST_PAD (destpeer), *caps);
|
|
|
|
|
2001-03-20 18:29:00 +00:00
|
|
|
GST_PAD_CAPS (destpad) = *caps;
|
2001-04-12 18:11:19 +00:00
|
|
|
if (GST_RPAD_NEWCAPSFUNC (destpad))
|
|
|
|
GST_RPAD_NEWCAPSFUNC (destpad) (GST_PAD (destpad), *caps);
|
2001-03-18 16:17:39 +00:00
|
|
|
}
|
|
|
|
else {
|
2001-04-12 18:11:19 +00:00
|
|
|
GST_DEBUG (GST_CAT_NEGOTIATION, "pads did not aggree on caps :(\n");
|
2001-03-18 16:17:39 +00:00
|
|
|
return GST_PAD_NEGOTIATE_FAIL;
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
2001-03-13 20:26:23 +00:00
|
|
|
}
|
2001-06-03 11:28:09 +00:00
|
|
|
else {
|
|
|
|
GST_PAD_CAPS (destpad) = *caps;
|
|
|
|
if (GST_RPAD_NEWCAPSFUNC (destpad))
|
|
|
|
GST_RPAD_NEWCAPSFUNC (destpad) (GST_PAD (destpad), *caps);
|
|
|
|
}
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-03-18 02:42:30 +00:00
|
|
|
return GST_PAD_NEGOTIATE_AGREE;
|
2001-03-12 21:02:12 +00:00
|
|
|
}
|
2000-09-27 19:33:10 +00:00
|
|
|
|
2001-06-25 06:45:56 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_save_thyself:
|
|
|
|
* @pad: the pad to save
|
|
|
|
* @parent: the parent XML node to save the description in
|
|
|
|
*
|
|
|
|
* Saves the pad into an xml representation
|
|
|
|
*
|
|
|
|
* Returns: the xml representation of the pad
|
|
|
|
*/
|
2001-01-29 00:06:02 +00:00
|
|
|
static xmlNodePtr
|
|
|
|
gst_pad_save_thyself (GstObject *object,
|
2001-01-21 23:20:46 +00:00
|
|
|
xmlNodePtr parent)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2001-01-19 02:23:35 +00:00
|
|
|
GstRealPad *realpad;
|
2000-01-30 09:03:00 +00:00
|
|
|
GstPad *peer;
|
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
g_return_val_if_fail (GST_IS_REAL_PAD (object), NULL);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
realpad = GST_REAL_PAD(object);
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-01-29 00:06:02 +00:00
|
|
|
xmlNewChild(parent,NULL,"name", GST_PAD_NAME (realpad));
|
2001-01-19 09:37:32 +00:00
|
|
|
if (GST_RPAD_PEER(realpad) != NULL) {
|
|
|
|
peer = GST_PAD(GST_RPAD_PEER(realpad));
|
2001-12-14 22:59:21 +00:00
|
|
|
/* first check to see if the peer's parent's parent is the same */
|
|
|
|
/* we just save it off */
|
2001-01-29 00:06:02 +00:00
|
|
|
xmlNewChild(parent,NULL,"peer",g_strdup_printf("%s.%s",
|
|
|
|
GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer)));
|
2000-01-30 09:03:00 +00:00
|
|
|
} else
|
2000-09-27 19:33:10 +00:00
|
|
|
xmlNewChild(parent,NULL,"peer","");
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2000-09-27 19:33:10 +00:00
|
|
|
return parent;
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
|
|
|
|
2000-10-25 19:09:53 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_ghost_save_thyself:
|
|
|
|
* @pad: the pad to save
|
|
|
|
* @bin: the bin
|
|
|
|
* @parent: the parent XML node to save the description in
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Saves the ghost pad into an xml representation.
|
2000-10-25 19:09:53 +00:00
|
|
|
*
|
|
|
|
* Returns: the xml representation of the pad
|
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
xmlNodePtr
|
2000-11-01 13:49:41 +00:00
|
|
|
gst_pad_ghost_save_thyself (GstPad *pad,
|
|
|
|
GstElement *bin,
|
2001-01-21 23:20:46 +00:00
|
|
|
xmlNodePtr parent)
|
2000-11-01 13:49:41 +00:00
|
|
|
{
|
2000-01-30 09:03:00 +00:00
|
|
|
xmlNodePtr self;
|
|
|
|
|
2001-01-19 09:37:32 +00:00
|
|
|
g_return_val_if_fail (GST_IS_GHOST_PAD (pad), NULL);
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
self = xmlNewChild(parent,NULL,"ghostpad",NULL);
|
2001-01-29 00:06:02 +00:00
|
|
|
xmlNewChild(self,NULL,"name", GST_PAD_NAME (pad));
|
|
|
|
xmlNewChild(self,NULL,"parent", GST_OBJECT_NAME (GST_PAD_PARENT (pad)));
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* FIXME FIXME FIXME! */
|
2001-01-19 09:37:32 +00:00
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
return self;
|
|
|
|
}
|
2001-10-17 10:21:27 +00:00
|
|
|
#endif /* GST_DISABLE_LOADSAVE */
|
2000-12-12 19:29:43 +00:00
|
|
|
|
2000-12-28 00:18:26 +00:00
|
|
|
#ifndef gst_pad_push
|
2001-02-22 23:18:51 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_push:
|
|
|
|
* @pad: the pad to push
|
|
|
|
* @buf: the buffer to push
|
|
|
|
*
|
|
|
|
* Push a buffer to the peer of the pad.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_pad_push (GstPad *pad, GstBuffer *buf)
|
|
|
|
{
|
|
|
|
GstRealPad *peer = GST_RPAD_PEER (pad);
|
|
|
|
|
|
|
|
GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
|
2001-05-25 21:00:07 +00:00
|
|
|
|
2001-05-30 20:36:01 +00:00
|
|
|
g_return_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SRC);
|
2001-12-22 21:18:17 +00:00
|
|
|
|
2001-12-20 02:41:34 +00:00
|
|
|
if (!peer) {
|
2001-12-22 21:18:17 +00:00
|
|
|
g_warning ("push on pad %s:%s but it is unconnected", GST_DEBUG_PAD_NAME (pad));
|
2001-12-20 02:41:34 +00:00
|
|
|
}
|
2001-11-14 21:08:44 +00:00
|
|
|
else {
|
2001-12-22 21:18:17 +00:00
|
|
|
if (peer->chainhandler) {
|
|
|
|
if (buf) {
|
|
|
|
GST_DEBUG (GST_CAT_DATAFLOW, "calling chainhandler &%s of peer pad %s:%s\n",
|
|
|
|
GST_DEBUG_FUNCPTR_NAME (peer->chainhandler), GST_DEBUG_PAD_NAME (GST_PAD (peer)));
|
|
|
|
(peer->chainhandler) (GST_PAD_CAST (peer), buf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_warning ("trying to push a NULL buffer on pad %s:%s", GST_DEBUG_PAD_NAME (peer));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_warning ("(internal error) push on pad %s:%s but it has no chainhandler", GST_DEBUG_PAD_NAME (peer));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* clean up the mess here */
|
|
|
|
if (buf != NULL) {
|
|
|
|
if (GST_IS_BUFFER (buf))
|
|
|
|
gst_buffer_unref (buf);
|
|
|
|
else
|
2001-12-24 15:14:03 +00:00
|
|
|
gst_event_free (GST_EVENT (buf));
|
2001-11-14 21:08:44 +00:00
|
|
|
}
|
2000-12-28 00:18:26 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef gst_pad_pull
|
2001-02-22 23:18:51 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_pull:
|
|
|
|
* @pad: the pad to pull
|
|
|
|
*
|
|
|
|
* Pull a buffer from the peer pad.
|
|
|
|
*
|
|
|
|
* Returns: a new buffer from the peer pad.
|
|
|
|
*/
|
|
|
|
GstBuffer*
|
|
|
|
gst_pad_pull (GstPad *pad)
|
|
|
|
{
|
2001-01-19 09:37:32 +00:00
|
|
|
GstRealPad *peer = GST_RPAD_PEER(pad);
|
2001-02-22 23:18:51 +00:00
|
|
|
|
2001-01-01 03:14:40 +00:00
|
|
|
GST_DEBUG_ENTER("(%s:%s)",GST_DEBUG_PAD_NAME(pad));
|
2001-02-22 23:18:51 +00:00
|
|
|
|
2001-05-30 20:36:01 +00:00
|
|
|
g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
|
2001-09-14 01:57:09 +00:00
|
|
|
|
2001-12-20 02:41:34 +00:00
|
|
|
if (!peer) {
|
2001-12-22 21:18:17 +00:00
|
|
|
gst_element_error (GST_PAD_PARENT (pad),
|
|
|
|
"pull on pad %s:%s but it was unconnected",
|
|
|
|
GST_ELEMENT_NAME (GST_PAD_PARENT (pad)), GST_PAD_NAME (pad),
|
|
|
|
NULL);
|
2001-12-20 02:41:34 +00:00
|
|
|
}
|
2001-12-22 21:18:17 +00:00
|
|
|
else {
|
|
|
|
if (peer->gethandler) {
|
|
|
|
GstBuffer *buf;
|
|
|
|
|
|
|
|
GST_DEBUG (GST_CAT_DATAFLOW, "calling gethandler %s of peer pad %s:%s\n",
|
|
|
|
GST_DEBUG_FUNCPTR_NAME (peer->gethandler), GST_DEBUG_PAD_NAME (peer));
|
|
|
|
|
|
|
|
buf = (peer->gethandler) (GST_PAD_CAST (peer));
|
|
|
|
if (buf)
|
|
|
|
return buf;
|
|
|
|
/* no null buffers allowed */
|
|
|
|
gst_element_error (GST_PAD_PARENT (pad),
|
|
|
|
"NULL buffer during pull on %s:%s", GST_DEBUG_PAD_NAME (pad), NULL);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
gst_element_error (GST_PAD_PARENT (pad),
|
|
|
|
"(internal error) pull on pad %s:%s but the peer pad %s:%s has no gethandler",
|
|
|
|
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (peer),
|
|
|
|
NULL);
|
|
|
|
}
|
2000-12-28 00:18:26 +00:00
|
|
|
}
|
2001-12-22 21:18:17 +00:00
|
|
|
return NULL;
|
2000-12-28 00:18:26 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef gst_pad_pullregion
|
2001-02-22 23:18:51 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_pullregion:
|
|
|
|
* @pad: the pad to pull the region from
|
|
|
|
* @type: the regiontype
|
|
|
|
* @offset: the offset/start of the buffer to pull
|
|
|
|
* @len: the length of the buffer to pull
|
|
|
|
*
|
|
|
|
* Pull a buffer region from the peer pad. The region to pull can be
|
|
|
|
* specified with a offset/lenght pair or with a start/legnth time
|
|
|
|
* indicator as specified by the type parameter.
|
|
|
|
*
|
|
|
|
* Returns: a new buffer from the peer pad with data in the specified
|
|
|
|
* region.
|
|
|
|
*/
|
|
|
|
GstBuffer*
|
|
|
|
gst_pad_pullregion (GstPad *pad, GstRegionType type, guint64 offset, guint64 len)
|
|
|
|
{
|
2001-06-13 21:33:31 +00:00
|
|
|
GstRealPad *peer;
|
|
|
|
GstBuffer *result = NULL;
|
2001-02-22 23:18:51 +00:00
|
|
|
|
2001-05-30 20:36:01 +00:00
|
|
|
g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
|
2001-02-22 23:18:51 +00:00
|
|
|
|
2001-06-13 21:33:31 +00:00
|
|
|
do {
|
|
|
|
peer = GST_RPAD_PEER(pad);
|
|
|
|
g_return_val_if_fail (peer != NULL, NULL);
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
gst_buffer_unref (result);
|
|
|
|
|
|
|
|
GST_DEBUG_ENTER("(%s:%s,%d,%lld,%lld)",GST_DEBUG_PAD_NAME(pad),type,offset,len);
|
2001-02-22 23:18:51 +00:00
|
|
|
|
2001-06-13 21:33:31 +00:00
|
|
|
if (peer->pullregionfunc) {
|
2001-12-20 02:41:34 +00:00
|
|
|
GST_DEBUG (GST_CAT_DATAFLOW, "calling pullregionfunc &%s of peer pad %s:%s\n",
|
2001-12-22 21:18:17 +00:00
|
|
|
GST_DEBUG_FUNCPTR_NAME (peer->pullregionfunc), GST_DEBUG_PAD_NAME(GST_PAD_CAST (peer)));
|
|
|
|
result = (peer->pullregionfunc) (GST_PAD_CAST (peer), type, offset, len);
|
2001-06-13 21:33:31 +00:00
|
|
|
} else {
|
|
|
|
GST_DEBUG (GST_CAT_DATAFLOW,"no pullregionfunc\n");
|
|
|
|
result = NULL;
|
|
|
|
break;
|
|
|
|
}
|
2000-12-28 00:18:26 +00:00
|
|
|
}
|
2001-06-15 19:13:45 +00:00
|
|
|
while (result && ! GST_BUFFER_FLAG_IS_SET (result, GST_BUFFER_EOS)
|
|
|
|
&& !(GST_BUFFER_OFFSET (result) == offset &&
|
2001-06-13 21:33:31 +00:00
|
|
|
GST_BUFFER_SIZE (result) == len));
|
|
|
|
|
|
|
|
return result;
|
2000-12-28 00:18:26 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-07-11 22:52:48 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_peek:
|
|
|
|
* @pad: the pad to peek
|
|
|
|
*
|
|
|
|
* Peek for a buffer from the peer pad.
|
|
|
|
*
|
|
|
|
* Returns: a from the peer pad or NULL if the peer has no buffer.
|
|
|
|
*/
|
|
|
|
GstBuffer*
|
|
|
|
gst_pad_peek (GstPad *pad)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
|
|
|
|
|
|
|
|
return GST_RPAD_BUFPEN (GST_RPAD_PEER (pad));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_pad_select:
|
|
|
|
* @padlist: A list of pads
|
|
|
|
*
|
|
|
|
* Wait for a buffer on the list of pads.
|
|
|
|
*
|
|
|
|
* Returns: The pad that has a buffer available, use
|
|
|
|
* #gst_pad_pull to get the buffer.
|
|
|
|
*/
|
|
|
|
GstPad*
|
|
|
|
gst_pad_select (GList *padlist)
|
|
|
|
{
|
2001-08-10 17:34:59 +00:00
|
|
|
GstPad *pad;
|
|
|
|
|
2001-12-19 19:22:53 +00:00
|
|
|
pad = gst_scheduler_pad_select (GST_PAD_PARENT (padlist->data)->sched, padlist);
|
2001-08-10 17:34:59 +00:00
|
|
|
|
|
|
|
return pad;
|
2001-07-11 22:52:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_pad_selectv:
|
|
|
|
* @pad: The first pad to perform the select on
|
|
|
|
* @...: More pads
|
|
|
|
*
|
|
|
|
* Wait for a buffer on the given of pads.
|
|
|
|
*
|
|
|
|
* Returns: The pad that has a buffer available, use
|
|
|
|
* #gst_pad_pull to get the buffer.
|
|
|
|
*/
|
|
|
|
GstPad*
|
|
|
|
gst_pad_selectv (GstPad *pad, ...)
|
|
|
|
{
|
|
|
|
GstPad *result;
|
|
|
|
GList *padlist = NULL;
|
|
|
|
va_list var_args;
|
|
|
|
|
|
|
|
if (pad == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
va_start (var_args, pad);
|
|
|
|
|
|
|
|
while (pad) {
|
|
|
|
padlist = g_list_prepend (padlist, pad);
|
|
|
|
pad = va_arg (var_args, GstPad *);
|
|
|
|
}
|
|
|
|
result = gst_pad_select (padlist);
|
|
|
|
g_list_free (padlist);
|
|
|
|
|
|
|
|
va_end (var_args);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2000-12-28 00:18:26 +00:00
|
|
|
/************************************************************************
|
2001-01-21 23:20:46 +00:00
|
|
|
*
|
2000-12-28 00:18:26 +00:00
|
|
|
* templates
|
|
|
|
*
|
|
|
|
*/
|
2001-03-07 21:52:56 +00:00
|
|
|
static void gst_padtemplate_class_init (GstPadTemplateClass *klass);
|
|
|
|
static void gst_padtemplate_init (GstPadTemplate *templ);
|
|
|
|
|
|
|
|
enum {
|
|
|
|
TEMPL_PAD_CREATED,
|
|
|
|
/* FILL ME */
|
|
|
|
TEMPL_LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
static GstObject *padtemplate_parent_class = NULL;
|
|
|
|
static guint gst_padtemplate_signals[TEMPL_LAST_SIGNAL] = { 0 };
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
GType
|
2001-03-07 21:52:56 +00:00
|
|
|
gst_padtemplate_get_type (void)
|
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
static GType padtemplate_type = 0;
|
2001-03-07 21:52:56 +00:00
|
|
|
|
|
|
|
if (!padtemplate_type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
static const GTypeInfo padtemplate_info = {
|
2001-03-07 21:52:56 +00:00
|
|
|
sizeof(GstPadTemplateClass),
|
2001-06-25 01:20:11 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc)gst_padtemplate_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
sizeof(GstPadTemplate),
|
|
|
|
32,
|
|
|
|
(GInstanceInitFunc)gst_padtemplate_init,
|
2001-09-14 22:16:47 +00:00
|
|
|
NULL
|
2001-03-07 21:52:56 +00:00
|
|
|
};
|
2001-06-25 01:20:11 +00:00
|
|
|
padtemplate_type = g_type_register_static(GST_TYPE_OBJECT, "GstPadTemplate", &padtemplate_info, 0);
|
2001-03-07 21:52:56 +00:00
|
|
|
}
|
|
|
|
return padtemplate_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_padtemplate_class_init (GstPadTemplateClass *klass)
|
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GObjectClass *gobject_class;
|
2001-03-07 21:52:56 +00:00
|
|
|
GstObjectClass *gstobject_class;
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class = (GObjectClass*)klass;
|
2001-03-07 21:52:56 +00:00
|
|
|
gstobject_class = (GstObjectClass*)klass;
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
padtemplate_parent_class = g_type_class_ref(GST_TYPE_OBJECT);
|
2001-03-07 21:52:56 +00:00
|
|
|
|
|
|
|
gst_padtemplate_signals[TEMPL_PAD_CREATED] =
|
2001-08-13 19:00:13 +00:00
|
|
|
g_signal_new ("pad_created", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
|
2001-06-25 01:20:11 +00:00
|
|
|
G_STRUCT_OFFSET (GstPadTemplateClass, pad_created), NULL, NULL,
|
2001-12-18 19:03:07 +00:00
|
|
|
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
|
|
|
|
G_TYPE_POINTER);
|
2001-03-07 21:52:56 +00:00
|
|
|
|
|
|
|
|
|
|
|
gstobject_class->path_string_separator = "*";
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_padtemplate_init (GstPadTemplate *templ)
|
|
|
|
{
|
|
|
|
}
|
2000-12-28 00:18:26 +00:00
|
|
|
|
2000-12-28 21:42:23 +00:00
|
|
|
/**
|
2001-04-19 22:25:04 +00:00
|
|
|
* gst_padtemplate_new:
|
2001-01-21 23:20:46 +00:00
|
|
|
* @name_template: the name template
|
2000-12-28 21:42:23 +00:00
|
|
|
* @direction: the direction for the template
|
|
|
|
* @presence: the presence of the pad
|
2000-12-31 16:12:48 +00:00
|
|
|
* @caps: a list of capabilities for the template
|
2001-04-19 22:25:04 +00:00
|
|
|
* @...: more capabilities
|
2000-12-28 21:42:23 +00:00
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Creates a new padtemplate from the given arguments.
|
2000-12-28 21:42:23 +00:00
|
|
|
*
|
|
|
|
* Returns: the new padtemplate
|
|
|
|
*/
|
2000-12-13 19:29:35 +00:00
|
|
|
GstPadTemplate*
|
2001-04-14 18:56:37 +00:00
|
|
|
gst_padtemplate_new (gchar *name_template,
|
|
|
|
GstPadDirection direction, GstPadPresence presence,
|
|
|
|
GstCaps *caps, ...)
|
2000-12-12 19:29:43 +00:00
|
|
|
{
|
2000-12-14 17:21:29 +00:00
|
|
|
GstPadTemplate *new;
|
2001-04-14 18:56:37 +00:00
|
|
|
va_list var_args;
|
|
|
|
GstCaps *thecaps = NULL;
|
2001-01-21 23:20:46 +00:00
|
|
|
|
2001-03-07 21:52:56 +00:00
|
|
|
g_return_val_if_fail (name_template != NULL, NULL);
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
new = g_object_new(gst_padtemplate_get_type () ,NULL);
|
2000-12-14 17:21:29 +00:00
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
GST_PADTEMPLATE_NAME_TEMPLATE (new) = name_template;
|
|
|
|
GST_PADTEMPLATE_DIRECTION (new) = direction;
|
|
|
|
GST_PADTEMPLATE_PRESENCE (new) = presence;
|
2001-04-14 18:56:37 +00:00
|
|
|
|
|
|
|
va_start (var_args, caps);
|
|
|
|
|
|
|
|
while (caps) {
|
|
|
|
thecaps = gst_caps_append (thecaps, caps);
|
|
|
|
caps = va_arg (var_args, GstCaps*);
|
|
|
|
}
|
|
|
|
va_end (var_args);
|
|
|
|
|
|
|
|
GST_PADTEMPLATE_CAPS (new) = thecaps;
|
2000-12-14 17:21:29 +00:00
|
|
|
|
|
|
|
return new;
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
/**
|
|
|
|
* gst_padtemplate_get_caps:
|
|
|
|
* @templ: the padtemplate to use
|
|
|
|
*
|
|
|
|
* Get the capabilities of the padtemplate
|
|
|
|
*
|
|
|
|
* Returns: a GstCaps*
|
|
|
|
*/
|
|
|
|
GstCaps*
|
|
|
|
gst_padtemplate_get_caps (GstPadTemplate *templ)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (templ != NULL, NULL);
|
|
|
|
|
|
|
|
return GST_PADTEMPLATE_CAPS (templ);
|
|
|
|
}
|
2000-12-13 19:29:35 +00:00
|
|
|
|
2001-09-10 19:46:01 +00:00
|
|
|
#ifndef GST_DISABLE_LOADSAVE
|
2000-12-28 21:42:23 +00:00
|
|
|
/**
|
|
|
|
* gst_padtemplate_save_thyself:
|
2001-01-19 22:15:21 +00:00
|
|
|
* @templ: the padtemplate to save
|
2000-12-28 21:42:23 +00:00
|
|
|
* @parent: the parent XML tree
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Saves the padtemplate into XML.
|
2000-12-28 21:42:23 +00:00
|
|
|
*
|
|
|
|
* Returns: the new XML tree
|
|
|
|
*/
|
2000-12-12 19:29:43 +00:00
|
|
|
xmlNodePtr
|
2001-01-19 22:15:21 +00:00
|
|
|
gst_padtemplate_save_thyself (GstPadTemplate *templ, xmlNodePtr parent)
|
2000-12-12 19:29:43 +00:00
|
|
|
{
|
|
|
|
xmlNodePtr subtree;
|
2001-01-18 23:46:15 +00:00
|
|
|
guchar *presence;
|
2000-12-12 19:29:43 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG (GST_CAT_XML,"saving padtemplate %s\n", templ->name_template);
|
2001-03-12 21:02:12 +00:00
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
xmlNewChild(parent,NULL,"nametemplate", templ->name_template);
|
|
|
|
xmlNewChild(parent,NULL,"direction", (templ->direction == GST_PAD_SINK? "sink":"src"));
|
2001-01-18 23:46:15 +00:00
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
switch (templ->presence) {
|
2001-01-18 23:46:15 +00:00
|
|
|
case GST_PAD_ALWAYS:
|
|
|
|
presence = "always";
|
|
|
|
break;
|
|
|
|
case GST_PAD_SOMETIMES:
|
|
|
|
presence = "sometimes";
|
|
|
|
break;
|
|
|
|
case GST_PAD_REQUEST:
|
|
|
|
presence = "request";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
presence = "unknown";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
xmlNewChild(parent,NULL,"presence", presence);
|
2000-12-12 19:29:43 +00:00
|
|
|
|
2001-03-12 21:02:12 +00:00
|
|
|
if (GST_PADTEMPLATE_CAPS (templ)) {
|
2001-01-19 22:15:21 +00:00
|
|
|
subtree = xmlNewChild (parent, NULL, "caps", NULL);
|
2001-03-12 21:02:12 +00:00
|
|
|
gst_caps_save_thyself (GST_PADTEMPLATE_CAPS (templ), subtree);
|
2000-12-31 16:12:48 +00:00
|
|
|
}
|
2000-12-12 19:29:43 +00:00
|
|
|
|
|
|
|
return parent;
|
|
|
|
}
|
|
|
|
|
2000-12-28 21:42:23 +00:00
|
|
|
/**
|
|
|
|
* gst_padtemplate_load_thyself:
|
|
|
|
* @parent: the source XML tree
|
|
|
|
*
|
2001-01-06 22:05:15 +00:00
|
|
|
* Loads a padtemplate from the XML tree.
|
2000-12-28 21:42:23 +00:00
|
|
|
*
|
|
|
|
* Returns: the new padtemplate
|
|
|
|
*/
|
2001-01-21 23:20:46 +00:00
|
|
|
GstPadTemplate*
|
2000-12-13 19:29:35 +00:00
|
|
|
gst_padtemplate_load_thyself (xmlNodePtr parent)
|
2000-12-12 19:29:43 +00:00
|
|
|
{
|
2001-02-15 18:42:13 +00:00
|
|
|
xmlNodePtr field = parent->xmlChildrenNode;
|
2001-03-07 21:52:56 +00:00
|
|
|
GstPadTemplate *factory;
|
|
|
|
gchar *name_template = NULL;
|
|
|
|
GstPadDirection direction = GST_PAD_UNKNOWN;
|
|
|
|
GstPadPresence presence = GST_PAD_ALWAYS;
|
2001-03-12 21:02:12 +00:00
|
|
|
GstCaps *caps = NULL;
|
2000-12-12 19:29:43 +00:00
|
|
|
|
|
|
|
while (field) {
|
|
|
|
if (!strcmp(field->name, "nametemplate")) {
|
2001-03-07 21:52:56 +00:00
|
|
|
name_template = xmlNodeGetContent(field);
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
|
|
|
if (!strcmp(field->name, "direction")) {
|
|
|
|
gchar *value = xmlNodeGetContent(field);
|
|
|
|
|
|
|
|
if (!strcmp(value, "sink")) {
|
2001-03-07 21:52:56 +00:00
|
|
|
direction = GST_PAD_SINK;
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
|
|
|
else if (!strcmp(value, "src")) {
|
2001-03-07 21:52:56 +00:00
|
|
|
direction = GST_PAD_SRC;
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
2001-01-07 07:45:54 +00:00
|
|
|
g_free (value);
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
|
|
|
if (!strcmp(field->name, "presence")) {
|
|
|
|
gchar *value = xmlNodeGetContent(field);
|
|
|
|
|
|
|
|
if (!strcmp(value, "always")) {
|
2001-03-07 21:52:56 +00:00
|
|
|
presence = GST_PAD_ALWAYS;
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
|
|
|
else if (!strcmp(value, "sometimes")) {
|
2001-03-07 21:52:56 +00:00
|
|
|
presence = GST_PAD_SOMETIMES;
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
2001-01-18 23:46:15 +00:00
|
|
|
else if (!strcmp(value, "request")) {
|
2001-03-07 21:52:56 +00:00
|
|
|
presence = GST_PAD_REQUEST;
|
2001-01-18 23:46:15 +00:00
|
|
|
}
|
2001-01-07 07:45:54 +00:00
|
|
|
g_free (value);
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
|
|
|
else if (!strcmp(field->name, "caps")) {
|
2001-03-12 21:02:12 +00:00
|
|
|
caps = gst_caps_load_thyself (field);
|
2000-12-12 19:29:43 +00:00
|
|
|
}
|
|
|
|
field = field->next;
|
|
|
|
}
|
2001-03-07 21:52:56 +00:00
|
|
|
|
2001-04-14 18:56:37 +00:00
|
|
|
factory = gst_padtemplate_new (name_template, direction, presence, caps, NULL);
|
2001-03-07 21:52:56 +00:00
|
|
|
|
2000-12-12 19:29:43 +00:00
|
|
|
return factory;
|
|
|
|
}
|
2001-09-10 19:46:01 +00:00
|
|
|
#endif /* !GST_DISABLE_LOADSAVE */
|
2000-12-12 19:29:43 +00:00
|
|
|
|
2000-12-31 22:18:05 +00:00
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_set_element_private:
|
|
|
|
* @pad: the pad to set the private data to
|
|
|
|
* @priv: The private data to attach to the pad
|
|
|
|
*
|
|
|
|
* Set the given private data pointer to the pad. This
|
|
|
|
* function can only be used by the element that own the
|
|
|
|
* pad.
|
|
|
|
*/
|
2001-01-11 22:03:01 +00:00
|
|
|
void
|
2001-01-13 13:51:08 +00:00
|
|
|
gst_pad_set_element_private (GstPad *pad, gpointer priv)
|
2001-01-11 22:03:01 +00:00
|
|
|
{
|
2001-01-13 13:51:08 +00:00
|
|
|
pad->element_private = priv;
|
2001-01-11 22:03:01 +00:00
|
|
|
}
|
|
|
|
|
2001-01-19 22:15:21 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_get_element_private:
|
|
|
|
* @pad: the pad to get the private data of
|
|
|
|
*
|
|
|
|
* Get the private data of a pad. The private data can
|
|
|
|
* only be set by the parent element of this pad.
|
|
|
|
*
|
|
|
|
* Returns: a pointer to the private data.
|
|
|
|
*/
|
2001-01-11 22:03:01 +00:00
|
|
|
gpointer
|
2001-01-11 22:09:29 +00:00
|
|
|
gst_pad_get_element_private (GstPad *pad)
|
2001-01-11 22:03:01 +00:00
|
|
|
{
|
2001-01-11 22:09:29 +00:00
|
|
|
return pad->element_private;
|
2001-01-11 22:03:01 +00:00
|
|
|
}
|
|
|
|
|
2001-01-19 02:23:35 +00:00
|
|
|
|
|
|
|
/***** ghost pads *****/
|
2001-10-17 10:21:27 +00:00
|
|
|
GType _gst_ghost_pad_type = 0;
|
2001-01-19 02:23:35 +00:00
|
|
|
|
|
|
|
static void gst_ghost_pad_class_init (GstGhostPadClass *klass);
|
|
|
|
static void gst_ghost_pad_init (GstGhostPad *pad);
|
|
|
|
|
|
|
|
static GstPad *ghost_pad_parent_class = NULL;
|
2001-12-14 22:59:21 +00:00
|
|
|
/* static guint gst_ghost_pad_signals[LAST_SIGNAL] = { 0 }; */
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
GType
|
2001-01-19 02:23:35 +00:00
|
|
|
gst_ghost_pad_get_type(void) {
|
2001-10-17 10:21:27 +00:00
|
|
|
if (!_gst_ghost_pad_type) {
|
2001-06-25 01:20:11 +00:00
|
|
|
static const GTypeInfo pad_info = {
|
2001-01-19 02:23:35 +00:00
|
|
|
sizeof(GstGhostPadClass),
|
2001-06-25 01:20:11 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc)gst_ghost_pad_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
sizeof(GstGhostPad),
|
|
|
|
8,
|
|
|
|
(GInstanceInitFunc)gst_ghost_pad_init,
|
2001-09-14 22:16:47 +00:00
|
|
|
NULL
|
2001-01-19 02:23:35 +00:00
|
|
|
};
|
2001-10-17 10:21:27 +00:00
|
|
|
_gst_ghost_pad_type = g_type_register_static(GST_TYPE_PAD, "GstGhostPad", &pad_info, 0);
|
2001-01-19 02:23:35 +00:00
|
|
|
}
|
2001-10-17 10:21:27 +00:00
|
|
|
return _gst_ghost_pad_type;
|
2001-01-19 02:23:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_ghost_pad_class_init (GstGhostPadClass *klass)
|
|
|
|
{
|
2001-06-25 01:20:11 +00:00
|
|
|
GObjectClass *gobject_class;
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
gobject_class = (GObjectClass*)klass;
|
2001-01-19 02:23:35 +00:00
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
ghost_pad_parent_class = g_type_class_ref(GST_TYPE_PAD);
|
2001-01-19 02:23:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gst_ghost_pad_init (GstGhostPad *pad)
|
|
|
|
{
|
|
|
|
pad->realpad = NULL;
|
|
|
|
}
|
2001-01-20 02:57:46 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_ghost_pad_new:
|
|
|
|
* @name: name of the new ghost pad
|
|
|
|
* @pad: the pad to create a ghost pad of
|
|
|
|
*
|
|
|
|
* Create a new ghost pad associated with the given pad.
|
|
|
|
*
|
|
|
|
* Returns: new ghost pad
|
|
|
|
*/
|
|
|
|
GstPad*
|
|
|
|
gst_ghost_pad_new (gchar *name,
|
|
|
|
GstPad *pad)
|
|
|
|
{
|
|
|
|
GstGhostPad *ghostpad;
|
|
|
|
|
|
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD(pad), NULL);
|
|
|
|
|
2001-06-25 01:20:11 +00:00
|
|
|
ghostpad = g_object_new(gst_ghost_pad_get_type () ,NULL);
|
2001-01-29 00:06:02 +00:00
|
|
|
gst_pad_set_name (GST_PAD (ghostpad), name);
|
2001-01-20 02:57:46 +00:00
|
|
|
GST_GPAD_REALPAD(ghostpad) = GST_PAD_REALIZE(pad);
|
2001-06-02 12:45:02 +00:00
|
|
|
GST_PAD_PADTEMPLATE(ghostpad) = GST_PAD_PADTEMPLATE(pad);
|
2001-01-20 02:57:46 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* add ourselves to the real pad's list of ghostpads */
|
2001-01-20 02:57:46 +00:00
|
|
|
gst_pad_add_ghost_pad (pad, GST_PAD(ghostpad));
|
2001-01-21 23:20:46 +00:00
|
|
|
|
2001-12-14 22:59:21 +00:00
|
|
|
/* FIXME need to ref the real pad here... ? */
|
2001-01-20 02:57:46 +00:00
|
|
|
|
2001-05-25 21:00:07 +00:00
|
|
|
GST_DEBUG(GST_CAT_PADS,"created ghost pad \"%s\"\n",name);
|
2001-01-20 02:57:46 +00:00
|
|
|
|
|
|
|
return GST_PAD(ghostpad);
|
|
|
|
}
|
2001-08-06 20:37:21 +00:00
|
|
|
|
|
|
|
|
2001-12-09 13:17:54 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_event_default:
|
|
|
|
* @pad: the pad to operate on
|
|
|
|
* @event: the event to handle
|
|
|
|
*
|
|
|
|
* Invoke the default event handler for the given pad.
|
|
|
|
*/
|
2001-11-14 21:08:44 +00:00
|
|
|
void
|
|
|
|
gst_pad_event_default (GstPad *pad, GstEvent *event)
|
2001-08-22 21:45:25 +00:00
|
|
|
{
|
2001-11-14 21:08:44 +00:00
|
|
|
GstElement *element = GST_PAD_PARENT (pad);
|
|
|
|
|
|
|
|
switch (GST_EVENT_TYPE (event)) {
|
2001-12-18 19:03:07 +00:00
|
|
|
case GST_EVENT_FLUSH:
|
2001-08-22 21:45:25 +00:00
|
|
|
case GST_EVENT_EOS:
|
2001-12-14 22:59:21 +00:00
|
|
|
/* gst_element_signal_eos (element); */
|
2001-11-14 21:08:44 +00:00
|
|
|
gst_element_set_state (element, GST_STATE_PAUSED);
|
|
|
|
{
|
|
|
|
GList *pads = element->pads;
|
|
|
|
|
|
|
|
while (pads) {
|
2001-12-04 22:12:50 +00:00
|
|
|
if (GST_PAD_DIRECTION (pads->data) == GST_PAD_SRC && GST_PAD_CONNECTED (pads->data)) {
|
2001-11-14 21:08:44 +00:00
|
|
|
gst_pad_push (GST_PAD (pads->data), GST_BUFFER (gst_event_new (GST_EVENT_TYPE (event))));
|
|
|
|
}
|
|
|
|
pads = g_list_next (pads);
|
|
|
|
}
|
|
|
|
}
|
2001-12-23 14:50:44 +00:00
|
|
|
gst_event_free (event);
|
2001-12-24 15:14:03 +00:00
|
|
|
/* we have to try to schedule another element because this one is disabled */
|
2001-12-22 21:18:17 +00:00
|
|
|
gst_element_yield (element);
|
2001-11-14 21:08:44 +00:00
|
|
|
break;
|
2001-10-21 18:00:31 +00:00
|
|
|
default:
|
2001-11-14 21:08:44 +00:00
|
|
|
g_warning ("no default handler for event\n");
|
2001-12-23 14:50:44 +00:00
|
|
|
gst_event_free (event);
|
2001-08-22 21:45:25 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-10-21 18:00:31 +00:00
|
|
|
/**
|
|
|
|
* gst_pad_send_event:
|
|
|
|
* @pad: the pad to send the event to
|
|
|
|
* @event: the event to send to the pad.
|
|
|
|
*
|
|
|
|
* Send the event to the pad.
|
|
|
|
*
|
2001-10-23 19:50:41 +00:00
|
|
|
* Returns: TRUE if the event was handled.
|
2001-10-21 18:00:31 +00:00
|
|
|
*/
|
2001-10-17 10:21:27 +00:00
|
|
|
gboolean
|
|
|
|
gst_pad_send_event (GstPad *pad, GstEvent *event)
|
|
|
|
{
|
|
|
|
gboolean handled = FALSE;
|
|
|
|
|
2001-10-23 19:50:41 +00:00
|
|
|
g_return_val_if_fail (event, FALSE);
|
|
|
|
|
2001-12-18 19:03:07 +00:00
|
|
|
if (GST_EVENT_SRC (event) == NULL)
|
|
|
|
GST_EVENT_SRC (event) = gst_object_ref (GST_OBJECT (pad));
|
|
|
|
|
2001-10-17 10:21:27 +00:00
|
|
|
GST_DEBUG (GST_CAT_EVENT, "have event %d on pad %s:%s\n",
|
|
|
|
GST_EVENT_TYPE (event), GST_DEBUG_PAD_NAME (pad));
|
|
|
|
|
|
|
|
if (GST_RPAD_EVENTFUNC (pad))
|
|
|
|
handled = GST_RPAD_EVENTFUNC (pad) (pad, event);
|
|
|
|
else {
|
|
|
|
GST_DEBUG(GST_CAT_EVENT, "there's no event function for pad %s:%s\n", GST_DEBUG_PAD_NAME (pad));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!handled) {
|
|
|
|
GST_DEBUG(GST_CAT_EVENT, "would proceed with default behavior here\n");
|
2001-11-14 21:21:58 +00:00
|
|
|
gst_pad_event_default (pad, event);
|
|
|
|
handled = TRUE;
|
2001-08-06 20:37:21 +00:00
|
|
|
}
|
2001-10-23 19:50:41 +00:00
|
|
|
|
|
|
|
return handled;
|
2001-08-06 20:37:21 +00:00
|
|
|
}
|
2001-10-17 10:21:27 +00:00
|
|
|
|