mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-09-29 15:22:17 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/gstpad.c
Erik Walthinsen c31f9a570c First pass at updating to new ghostpad system. The objects are in place, 
Original commit message from CVS:
First pass at updating to new ghostpad system.  The objects are in place,
I now need to go and get all the Bin end of things worked out.  Testing
should be fairly easy, at least for verification.

Everything I've tried so far works with no changes, with is amazing.
That's just cool.  Once again we rewrite an entire subsystem, and nothing
else notices anything but the new features ;-)
2001-01-19 02:23:35 +00:00

1310 lines
32 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstpad.c: Pads for connecting elements together
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
//#define GST_DEBUG_ENABLED
#include "gst_private.h"
#include "gstpad.h"
#include "gstelement.h"
#include "gsttype.h"
/* Pad signals and args */
enum {
SET_ACTIVE,
CAPS_CHANGED,
/* FILL ME */
LAST_SIGNAL
};
enum {
ARG_0,
ARG_ACTIVE,
/* FILL ME */
};
/***** Start with the base GstPad class *****/
static void gst_pad_class_init (GstPadClass *klass);
static void gst_pad_init (GstPad *pad);
static GstObject *pad_parent_class = NULL;
GtkType
gst_pad_get_type(void) {
static GtkType pad_type = 0;
if (!pad_type) {
static const GtkTypeInfo pad_info = {
"GstPad",
sizeof(GstPad),
sizeof(GstPadClass),
(GtkClassInitFunc)gst_pad_class_init,
(GtkObjectInitFunc)gst_pad_init,
(GtkArgSetFunc)NULL,
(GtkArgGetFunc)NULL,
(GtkClassInitFunc)NULL,
};
pad_type = gtk_type_unique(GST_TYPE_OBJECT,&pad_info);
}
return pad_type;
}
static void
gst_pad_class_init (GstPadClass *klass)
{
pad_parent_class = gtk_type_class(GST_TYPE_OBJECT);
}
static void
gst_pad_init (GstPad *pad)
{
pad->name = NULL;
pad->element_private = NULL;
pad->parent = NULL;
pad->padtemplate = NULL;
}
/***** Then do the Real Pad *****/
static void gst_real_pad_class_init (GstRealPadClass *klass);
static void gst_real_pad_init (GstRealPad *pad);
static void gst_real_pad_set_arg (GtkObject *object,GtkArg *arg,guint id);
static void gst_real_pad_get_arg (GtkObject *object,GtkArg *arg,guint id);
static void gst_real_pad_destroy (GtkObject *object);
static void gst_pad_push_func (GstPad *pad, GstBuffer *buf);
static GstPad *real_pad_parent_class = NULL;
static guint gst_real_pad_signals[LAST_SIGNAL] = { 0 };
GtkType
gst_real_pad_get_type(void) {
static GtkType pad_type = 0;
if (!pad_type) {
static const GtkTypeInfo pad_info = {
"GstRealPad",
sizeof(GstRealPad),
sizeof(GstRealPadClass),
(GtkClassInitFunc)gst_real_pad_class_init,
(GtkObjectInitFunc)gst_real_pad_init,
(GtkArgSetFunc)NULL,
(GtkArgGetFunc)NULL,
(GtkClassInitFunc)NULL,
};
pad_type = gtk_type_unique(GST_TYPE_PAD,&pad_info);
}
return pad_type;
}
static void
gst_real_pad_class_init (GstRealPadClass *klass)
{
GtkObjectClass *gtkobject_class;
gtkobject_class = (GtkObjectClass*)klass;
real_pad_parent_class = gtk_type_class(GST_TYPE_PAD);
gst_real_pad_signals[SET_ACTIVE] =
gtk_signal_new ("set_active", GTK_RUN_LAST, gtkobject_class->type,
GTK_SIGNAL_OFFSET (GstRealPadClass, set_active),
gtk_marshal_NONE__BOOL, GTK_TYPE_NONE, 1,
GTK_TYPE_BOOL);
gst_real_pad_signals[CAPS_CHANGED] =
gtk_signal_new ("caps_changed", GTK_RUN_LAST, gtkobject_class->type,
GTK_SIGNAL_OFFSET (GstRealPadClass, caps_changed),
gtk_marshal_NONE__POINTER, GTK_TYPE_NONE, 1,
GTK_TYPE_POINTER);
gtk_object_class_add_signals (gtkobject_class, gst_real_pad_signals, LAST_SIGNAL);
gtk_object_add_arg_type ("GstRealPad::active", GTK_TYPE_BOOL,
GTK_ARG_READWRITE, ARG_ACTIVE);
gtkobject_class->destroy = gst_real_pad_destroy;
gtkobject_class->set_arg = gst_real_pad_set_arg;
gtkobject_class->get_arg = gst_real_pad_get_arg;
}
static void
gst_real_pad_init (GstRealPad *pad)
{
pad->direction = GST_PAD_UNKNOWN;
pad->peer = NULL;
pad->chainfunc = NULL;
pad->getfunc = NULL;
pad->getregionfunc = NULL;
pad->qosfunc = NULL;
pad->eosfunc = gst_pad_eos_func;
pad->pushfunc = GST_DEBUG_FUNCPTR(gst_pad_push_func);
pad->pullfunc = NULL;
pad->pullregionfunc = NULL;
pad->ghostparents = NULL;
pad->caps = NULL;
}
static void
gst_real_pad_set_arg (GtkObject *object, GtkArg *arg, guint id)
{
g_return_if_fail(GST_IS_PAD(object));
switch (id) {
case ARG_ACTIVE:
if (GTK_VALUE_BOOL(*arg)) {
gst_info("gstpad: activating pad\n");
GST_FLAG_UNSET(object,GST_PAD_DISABLED);
} else {
gst_info("gstpad: de-activating pad\n");
GST_FLAG_SET(object,GST_PAD_DISABLED);
}
gtk_signal_emit(GTK_OBJECT(object), gst_real_pad_signals[SET_ACTIVE],
! GST_FLAG_IS_SET(object,GST_PAD_DISABLED));
break;
default:
break;
}
}
static void
gst_real_pad_get_arg (GtkObject *object, GtkArg *arg, guint id)
{
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_PAD (object));
switch (id) {
case ARG_ACTIVE:
GTK_VALUE_BOOL (*arg) = ! GST_FLAG_IS_SET (object, GST_PAD_DISABLED);
break;
default:
break;
}
}
/**
* 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
*/
GstPad*
gst_pad_new (gchar *name,
GstPadDirection direction)
{
GstPad *pad;
GstRealPad *realpad;
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (direction != GST_PAD_UNKNOWN, NULL);
realpad = gtk_type_new (gst_real_pad_get_type ());
pad = GST_PAD(realpad);
pad->name = g_strdup (name);
realpad->direction = direction;
return pad;
}
/**
* gst_pad_new_from_template:
* @temp: the pad template to use
* @name: the name of the element
*
* Create a new pad with given name from the given template.
*
* Returns: new pad
*/
GstPad*
gst_pad_new_from_template (GstPadTemplate *templ,
gchar *name)
{
GstPad *pad;
GstRealPad *realpad;
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (templ != NULL, NULL);
pad = gst_pad_new (name, templ->direction);
realpad = GST_REAL_PAD (pad);
realpad->caps = templ->caps;
pad->padtemplate = templ;
return pad;
}
/**
* gst_pad_get_direction:
* @pad: the Pad to get the direction from
*
* Get the direction of the pad.
*
* Returns: the direction of the pad
*/
GstPadDirection
gst_pad_get_direction (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, GST_PAD_UNKNOWN);
g_return_val_if_fail (GST_IS_REAL_PAD (pad), GST_PAD_UNKNOWN);
return GST_REAL_PAD(pad)->direction;
}
/**
* gst_pad_set_name:
* @pad: the pad to set the name of
* @name: the name of the pad
*
* Set the name of a pad.
*/
void
gst_pad_set_name (GstPad *pad,
const gchar *name)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
if (pad->name != NULL)
g_free (pad->name);
pad->name = g_strdup (name);
}
/**
* gst_pad_get_name:
* @pad: the pad to get the name of
*
* Get the name of a pad.
*
* Returns: the name of the pad, don't free.
*/
const gchar*
gst_pad_get_name (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
return pad->name;
}
/**
* gst_pad_set_chain_function:
* @pad: the pad to set the chain function for
* @chain: the chain function
*
* Set the given chain function for the pad.
*/
void gst_pad_set_chain_function (GstPad *pad,
GstPadChainFunction chain)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad));
GST_REAL_PAD(pad)->chainfunc = chain;
}
/**
* gst_pad_set_get_function:
* @pad: the pad to set the get function for
* @get: the get function
*
* Set the given get function for the pad.
*/
void
gst_pad_set_get_function (GstPad *pad,
GstPadGetFunction get)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad));
// the if and such should optimize out when DEBUG is off
GST_DEBUG (0,"setting get function for %s:%s\n",GST_DEBUG_PAD_NAME(pad));
GST_REAL_PAD(pad)->getfunc = get;
GST_DEBUG (0,"getfunc for %s:%s(@%p) at %p is set to %p\n",
GST_DEBUG_PAD_NAME(pad),pad,&GST_REAL_PAD(pad)->getfunc,get);
}
/**
* gst_pad_set_getregion_function:
* @pad: the pad to set the getregion function for
* @getregion: the getregion function
*
* Set the given getregion function for the pad.
*/
void
gst_pad_set_getregion_function (GstPad *pad,
GstPadGetRegionFunction getregion)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad));
GST_DEBUG (0,"gstpad: pad setting getregion function\n");
GST_REAL_PAD(pad)->getregionfunc = getregion;
}
/**
* gst_pad_set_qos_function:
* @pad: the pad to set the qos function for
* @qos: the qos function
*
* Set the given qos function for the pad.
*/
void
gst_pad_set_qos_function (GstPad *pad,
GstPadQoSFunction qos)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad));
GST_REAL_PAD(pad)->qosfunc = qos;
}
/**
* gst_pad_set_eos_function:
* @pad: the pad to set the eos function for
* @eos: the eos function
*
* Set the given EOS function for the pad.
*/
void
gst_pad_set_eos_function (GstPad *pad,
GstPadEOSFunction eos)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad));
GST_REAL_PAD(pad)->eosfunc = eos;
}
static void
gst_pad_push_func(GstPad *pad, GstBuffer *buf)
{
GstRealPad *realpad = GST_REAL_PAD(pad);
if (realpad->peer->chainfunc != NULL) {
GST_DEBUG (0,"calling chain function\n");
(realpad->peer->chainfunc)(pad,buf);
} else {
GST_DEBUG (0,"got a problem here: default pad_push handler in place, no chain function\n");
}
}
/**
* gst_pad_handle_qos:
* @pad: the pad to handle the QoS message
* @qos_message: the QoS message to handle
*
* Pass the qos message downstream.
*/
void
gst_pad_handle_qos(GstPad *pad,
glong qos_message)
{
GstRealPad *realpad = GST_REAL_PAD (pad);
GstElement *element;
GList *pads;
GstPad *target_pad;
GST_DEBUG (0,"gst_pad_handle_qos(\"%s\",%08ld)\n", GST_ELEMENT(pad->parent)->name,qos_message);
if (realpad->qosfunc) {
(realpad->qosfunc) (pad,qos_message);
} else {
element = GST_ELEMENT (GST_PAD(realpad->peer)->parent);
pads = element->pads;
GST_DEBUG (0,"gst_pad_handle_qos recurse(\"%s\",%08ld)\n", element->name, qos_message);
while (pads) {
target_pad = GST_PAD (pads->data);
if (GST_REAL_PAD(target_pad)->direction == GST_PAD_SINK) {
gst_pad_handle_qos (target_pad, qos_message);
}
pads = g_list_next (pads);
}
}
return;
}
/**
* gst_pad_disconnect:
* @srcpad: the source pad to disconnect
* @sinkpad: the sink pad to disconnect
*
* Disconnects the source pad from the sink pad.
*/
void
gst_pad_disconnect (GstPad *srcpad,
GstPad *sinkpad)
{
GstRealPad *realsrc, *realsink;
/* generic checks */
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));
// now we need to deal with the real/ghost stuff
if (GST_IS_GHOST_PAD(srcpad)) realsrc = GST_GHOST_PAD(srcpad)->realpad;
else realsrc = GST_REAL_PAD(srcpad);
if (GST_IS_GHOST_PAD(sinkpad)) realsink = GST_GHOST_PAD(sinkpad)->realpad;
else realsink = GST_REAL_PAD(sinkpad);
g_return_if_fail (realsrc->peer != NULL);
g_return_if_fail (realsink->peer != NULL);
g_return_if_fail ((realsrc->direction == GST_PAD_SRC) &&
(realsink->direction == GST_PAD_SINK));
/* first clear peers */
realsrc->peer = NULL;
realsink->peer = NULL;
GST_INFO (GST_CAT_ELEMENT_PADS, "disconnected %s:%s and %s:%s",
GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
}
/**
* gst_pad_connect:
* @srcpad: the source pad to connect
* @sinkpad: the sink pad to connect
*
* Connects the source pad to the sink pad.
*/
void
gst_pad_connect (GstPad *srcpad,
GstPad *sinkpad)
{
GstRealPad *realsrc, *realsink;
GstRealPad *temppad;
/* generic checks */
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));
// g_return_if_fail(sinkpad->chain != NULL);
// now we need to deal with the real/ghost stuff
if (GST_IS_GHOST_PAD(srcpad)) realsrc = GST_GHOST_PAD(srcpad)->realpad;
else realsrc = GST_REAL_PAD(srcpad);
if (GST_IS_GHOST_PAD(sinkpad)) realsink = GST_GHOST_PAD(sinkpad)->realpad;
else realsink = GST_REAL_PAD(sinkpad);
g_return_if_fail(realsrc->peer == NULL);
g_return_if_fail(realsink->peer == NULL);
/* check for reversed directions and swap if necessary */
if ((realsrc->direction == GST_PAD_SINK) &&
(realsink->direction == GST_PAD_SRC)) {
temppad = realsrc;
realsrc = realsink;
realsink = temppad;
}
g_return_if_fail((realsrc->direction == GST_PAD_SRC) &&
(realsink->direction == GST_PAD_SINK));
if (!gst_pad_check_compatibility (srcpad, sinkpad)) {
g_warning ("gstpad: connecting incompatible pads (%s:%s) and (%s:%s)\n",
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
}
else {
GST_DEBUG (0,"gstpad: connecting compatible pads (%s:%s) and (%s:%s)\n",
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
}
/* first set peers */
realsrc->peer = realsink;
realsink->peer = realsrc;
// FIXME this is irrelevant now
/* now copy the chain pointer from sink to src */
//srcpad->chainfunc = sinkpad->chainfunc;
/* and the pull function */
//srcpad->pullfunc = sinkpad->pullfunc;
/* set the connected flag */
/* FIXME: set connected flag */
GST_INFO (GST_CAT_ELEMENT_PADS, "connected %s:%s and %s:%s",
GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
}
/**
* gst_pad_set_parent:
* @pad: the pad to set the parent
* @parent: the object to set the parent to
*
* Sets the parent object of a pad.
*/
void
gst_pad_set_parent (GstPad *pad,
GstObject *parent)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
g_return_if_fail (pad->parent == NULL);
g_return_if_fail (parent != NULL);
g_return_if_fail (GTK_IS_OBJECT (parent));
g_return_if_fail ((gpointer)pad != (gpointer)parent);
//g_print("set parent %s\n", gst_element_get_name(parent));
pad->parent = parent;
}
/**
* gst_pad_add_ghost_parent:
* @pad: the pad to set the ghost parent
* @parent: the object to set the ghost parent to
*
* Add a ghost parent object to a pad.
*/
void
gst_pad_add_ghost_parent (GstPad *pad,
GstObject *parent)
{
GstRealPad *realpad;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad)); // NOTE this restriction
g_return_if_fail (parent != NULL);
g_return_if_fail (GTK_IS_OBJECT (parent));
realpad = GST_REAL_PAD (pad);
/* FIXME is this going to be needed?
// now we need to deal with the real/ghost stuff
if (GST_IS_GHOST_PAD(srcpad)) realsrc = GST_GHOST_PAD(srcpad)->realpad;
else realsrc = GST_REAL_PAD(srcpad);
*/
realpad->ghostparents = g_list_prepend (realpad->ghostparents, parent);
}
/**
* gst_pad_remove_ghost_parent:
* @pad: the pad to remove the ghost parent
* @parent: the object to remove the ghost parent from
*
* Remove a ghost parent object from a pad.
*/
void
gst_pad_remove_ghost_parent (GstPad *pad,
GstObject *parent)
{
GstRealPad *realpad;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad)); // NOTE this restriction
g_return_if_fail (parent != NULL);
g_return_if_fail (GTK_IS_OBJECT (parent));
realpad = GST_REAL_PAD (pad);
realpad->ghostparents = g_list_remove (realpad->ghostparents, parent);
}
/**
* gst_pad_get_parent:
* @pad: the pad to get the parent from
*
* Get the parent object of this pad.
*
* Returns: the parent object
*/
GstObject*
gst_pad_get_parent (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
return pad->parent;
}
/**
* gst_pad_get_ghost_parents:
* @pad: the pad to get the ghost parents from
*
* Get the ghost parents of this pad.
*
* Returns: a GList of ghost parent objects
*/
GList*
gst_pad_get_ghost_parents (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_REAL_PAD (pad), NULL); // NOTE this restriction
return GST_REAL_PAD(pad)->ghostparents;
}
/**
* gst_pad_set_caps_list:
* @pad: the pad to set the caps to
* @caps: the capslist to attach to this pad
*
* Set the capabilities of this pad.
*/
void
gst_pad_set_caps_list (GstPad *pad,
GList *caps)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad)); // NOTE this restriction
GST_REAL_PAD(pad)->caps = caps;
}
/**
* gst_pad_get_caps_list:
* @pad: the pad to get the capabilities from
*
* Get the capabilities of this pad.
*
* Returns: a list of capabilities of this pad
*/
GList *
gst_pad_get_caps_list (GstPad *pad)
{
GstRealPad *realpad;
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
// find the real pad
if (GST_IS_GHOST_PAD (pad)) realpad = GST_GHOST_PAD(pad)->realpad;
else realpad = GST_REAL_PAD(pad);
return realpad->caps;
}
/**
* gst_pad_get_caps_by_name:
* @pad: the pad to get the capabilities from
* @name: the name of the capability to get
*
* Get the capabilities with the given name from this pad.
*
* Returns: a capability or NULL if not found
*/
GstCaps *
gst_pad_get_caps_by_name (GstPad *pad, gchar *name)
{
GstRealPad *realpad;
GList *caps;
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
// find the real pad
if (GST_IS_GHOST_PAD (pad)) realpad = GST_GHOST_PAD(pad)->realpad;
else realpad = GST_REAL_PAD(pad);
caps = realpad->caps;
while (caps) {
GstCaps *cap = (GstCaps *)caps->data;
if (!strcmp (cap->name, name))
return cap;
caps = g_list_next (caps);
}
return NULL;
}
/**
* gst_pad_check_compatibility:
* @srcpad: the srcpad to check
* @sinkpad: the sinkpad to check against
*
* Check if two pads have compatible capabilities.
*
* Returns: TRUE if they are compatible or the capabilities
* could not be checked
*/
gboolean
gst_pad_check_compatibility (GstPad *srcpad, GstPad *sinkpad)
{
GstRealPad *realsrc, *realsink;
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);
// find the real pad
if (GST_IS_GHOST_PAD (srcpad)) realsrc = GST_GHOST_PAD(srcpad)->realpad;
else realsrc = GST_REAL_PAD(srcpad);
if (GST_IS_GHOST_PAD (sinkpad)) realsink = GST_GHOST_PAD(sinkpad)->realpad;
else realsink = GST_REAL_PAD(sinkpad);
if (realsrc->caps && realsink->caps) {
if (!gst_caps_list_check_compatibility (realsrc->caps, realsink->caps)) {
return FALSE;
}
else {
return TRUE;
}
}
else {
GST_DEBUG (0,"gstpad: could not check capabilities of pads (%s:%s) and (%s:%s)\n",
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
return TRUE;
}
}
/**
* gst_pad_get_peer:
* @pad: the pad to get the peer from
*
* Get the peer pad of this pad.
*
* Returns: the peer pad
*/
GstPad*
gst_pad_get_peer (GstPad *pad)
{
GstRealPad *realpad;
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
// find the real pad
if (GST_IS_GHOST_PAD (pad)) realpad = GST_GHOST_PAD(pad)->realpad;
else realpad = GST_REAL_PAD(pad);
return GST_PAD(realpad->peer);
}
// FIXME this needs to be rethought soon
static void
gst_real_pad_destroy (GtkObject *object)
{
GstPad *pad = GST_PAD (object);
// g_print("in gst_pad_real_destroy()\n");
if (pad->name)
g_free (pad->name);
g_list_free (GST_REAL_PAD(pad)->ghostparents);
}
/**
* gst_pad_load_and_connect:
* @parent: the parent XML node to read the description from
* @element: the element that has the source pad
* @elements: a hashtable with elements
*
* Read the pad definition from the XML node and connect the given pad
* in element to a pad of an element in the hashtable.
*/
void
gst_pad_load_and_connect (xmlNodePtr parent,
GstObject *element,
GHashTable *elements)
{
xmlNodePtr field = parent->childs;
GstPad *pad = NULL, *targetpad;
guchar *peer = NULL;
gchar **split;
GstElement *target;
while (field) {
if (!strcmp(field->name, "name")) {
pad = gst_element_get_pad(GST_ELEMENT(element), xmlNodeGetContent(field));
}
else if (!strcmp(field->name, "peer")) {
peer = g_strdup(xmlNodeGetContent(field));
}
field = field->next;
}
g_return_if_fail(pad != NULL);
if (peer == NULL) return;
split = g_strsplit(peer, ".", 2);
g_return_if_fail(split[0] != NULL);
g_return_if_fail(split[1] != NULL);
target = (GstElement *)g_hash_table_lookup(elements, split[0]);
if (target == NULL) goto cleanup;
targetpad = gst_element_get_pad(target, split[1]);
if (targetpad == NULL) goto cleanup;
gst_pad_connect(pad, targetpad);
cleanup:
g_strfreev(split);
}
/**
* 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
*/
xmlNodePtr
gst_pad_save_thyself (GstPad *pad,
xmlNodePtr parent)
{
GstRealPad *realpad;
GstPad *peer;
// FIXME ?
if (GST_IS_GHOST_PAD(pad)) return NULL;
realpad = GST_REAL_PAD(pad);
xmlNewChild(parent,NULL,"name",pad->name);
if (realpad->peer != NULL) {
peer = GST_PAD(realpad->peer);
// first check to see if the peer's parent's parent is the same
//if (pad->parent->parent == peer->parent->parent)
// we just save it off
xmlNewChild(parent,NULL,"peer",g_strdup_printf("%s.%s",
GST_ELEMENT(peer->parent)->name,peer->name));
} else
xmlNewChild(parent,NULL,"peer","");
return parent;
}
/**
* gst_pad_ghost_save_thyself:
* @pad: the pad to save
* @bin: the bin
* @parent: the parent XML node to save the description in
*
* Saves the ghost pad into an xml representation.
*
* Returns: the xml representation of the pad
*/
xmlNodePtr
gst_pad_ghost_save_thyself (GstPad *pad,
GstElement *bin,
xmlNodePtr parent)
{
xmlNodePtr self;
self = xmlNewChild(parent,NULL,"ghostpad",NULL);
xmlNewChild(self,NULL,"name",pad->name);
xmlNewChild(self,NULL,"parent",GST_ELEMENT(pad->parent)->name);
return self;
}
#ifndef gst_pad_push
void gst_pad_push(GstPad *pad,GstBuffer *buf) {
GstRealPad *realpad = GST_REAL_PAD(pad);
GST_DEBUG_ENTER("(%s:%s)",GST_DEBUG_PAD_NAME(pad));
if (realpad->peer->pushfunc) {
GST_DEBUG (0,"calling pushfunc &%s of peer pad %s:%s\n",
GST_DEBUG_FUNCPTR_NAME(realpad->peer->pushfunc),GST_DEBUG_PAD_NAME(GST_PAD(realpad->peer)));
(realpad->peer->pushfunc)(GST_PAD(realpad->peer),buf);
} else
GST_DEBUG (0,"no pushfunc\n");
}
#endif
#ifndef gst_pad_pull
GstBuffer *gst_pad_pull(GstPad *pad) {
GstRealPad *realpad = GST_REAL_PAD(pad);
GstRealPad *peer = realpad->peer;
GST_DEBUG_ENTER("(%s:%s)",GST_DEBUG_PAD_NAME(pad));
if (peer->pullfunc) {
GST_DEBUG (0,"calling pullfunc &%s (@%p) of peer pad %s:%s\n",
GST_DEBUG_FUNCPTR_NAME(peer->pullfunc),&peer->pullfunc,GST_DEBUG_PAD_NAME(GST_PAD(peer)));
return (peer->pullfunc)(GST_PAD(peer));
} else {
GST_DEBUG (0,"no pullfunc for peer pad %s:%s at %p\n",GST_DEBUG_PAD_NAME(GST_PAD(peer)),&peer->pullfunc);
return NULL;
}
}
#endif
#ifndef gst_pad_pullregion
GstBuffer *gst_pad_pullregion(GstPad *pad,gulong offset,gulong size) {
GstRealPad *realpad = GST_REAL_PAD(pad);
GST_DEBUG_ENTER("(%s:%s,%ld,%ld)",GST_DEBUG_PAD_NAME(pad),offset,size);
if (realpad->peer->pullregionfunc) {
GST_DEBUG (0,"calling pullregionfunc &%s of peer pad %s:%s\n",
GST_DEBUG_FUNCPTR_NAME(realpad->peer->pullregionfunc),GST_DEBUG_PAD_NAME(GST_PAD(realpad->peer)));
return (realpad->peer->pullregionfunc)(GST_PAD(realpad->peer),offset,size);
} else {
GST_DEBUG (0,"no pullregionfunc\n");
return NULL;
}
}
#endif
/************************************************************************
*
* templates
*
*/
/**
* gst_padtemplate_new:
* @factory: the padfactory to use
*
* Creates a new padtemplate from the factory.
*
* Returns: the new padtemplate
*/
GstPadTemplate*
gst_padtemplate_new (GstPadFactory *factory)
{
GstPadTemplate *new;
GstPadFactoryEntry tag;
gint i = 0;
guint counter = 0;
g_return_val_if_fail (factory != NULL, NULL);
new = g_new0 (GstPadTemplate, 1);
tag = (*factory)[i++];
g_return_val_if_fail (tag != NULL, new);
new->name_template = g_strdup ((gchar *)tag);
tag = (*factory)[i++];
new->direction = GPOINTER_TO_UINT (tag);
tag = (*factory)[i++];
new->presence = GPOINTER_TO_UINT (tag);
tag = (*factory)[i++];
while (GPOINTER_TO_INT (tag) == 1) {
new->caps = g_list_append (new->caps, gst_caps_register_count ((GstCapsFactory *)&(*factory)[i], &counter));
i+=counter;
tag = (*factory)[i++];
}
return new;
}
/**
* gst_padtemplate_create:
* @name_template: the name template
* @direction: the direction for the template
* @presence: the presence of the pad
* @caps: a list of capabilities for the template
*
* Creates a new padtemplate from the given arguments.
*
* Returns: the new padtemplate
*/
GstPadTemplate*
gst_padtemplate_create (gchar *name_template,
GstPadDirection direction, GstPadPresence presence,
GList *caps)
{
GstPadTemplate *new;
new = g_new0 (GstPadTemplate, 1);
new->name_template = name_template;
new->direction = direction;
new->presence = presence;
new->caps = caps;
return new;
}
/**
* gst_padtemplate_save_thyself:
* @pad: the padtemplate to save
* @parent: the parent XML tree
*
* Saves the padtemplate into XML.
*
* Returns: the new XML tree
*/
xmlNodePtr
gst_padtemplate_save_thyself (GstPadTemplate *pad, xmlNodePtr parent)
{
xmlNodePtr subtree;
GList *caps;
guchar *presence;
xmlNewChild(parent,NULL,"nametemplate", pad->name_template);
xmlNewChild(parent,NULL,"direction", (pad->direction == GST_PAD_SINK? "sink":"src"));
switch (pad->presence) {
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);
caps = pad->caps;
while (caps) {
GstCaps *cap = (GstCaps *)caps->data;
subtree = xmlNewChild(parent,NULL,"caps", NULL);
gst_caps_save_thyself (cap, subtree);
caps = g_list_next (caps);
}
return parent;
}
/**
* gst_padtemplate_load_thyself:
* @parent: the source XML tree
*
* Loads a padtemplate from the XML tree.
*
* Returns: the new padtemplate
*/
GstPadTemplate*
gst_padtemplate_load_thyself (xmlNodePtr parent)
{
xmlNodePtr field = parent->childs;
GstPadTemplate *factory = g_new0 (GstPadTemplate, 1);
while (field) {
if (!strcmp(field->name, "nametemplate")) {
factory->name_template = xmlNodeGetContent(field);
}
if (!strcmp(field->name, "direction")) {
gchar *value = xmlNodeGetContent(field);
factory->direction = GST_PAD_UNKNOWN;
if (!strcmp(value, "sink")) {
factory->direction = GST_PAD_SINK;
}
else if (!strcmp(value, "src")) {
factory->direction = GST_PAD_SRC;
}
g_free (value);
}
if (!strcmp(field->name, "presence")) {
gchar *value = xmlNodeGetContent(field);
if (!strcmp(value, "always")) {
factory->presence = GST_PAD_ALWAYS;
}
else if (!strcmp(value, "sometimes")) {
factory->presence = GST_PAD_SOMETIMES;
}
else if (!strcmp(value, "request")) {
factory->presence = GST_PAD_REQUEST;
}
g_free (value);
}
else if (!strcmp(field->name, "caps")) {
factory->caps = g_list_append(factory->caps, gst_caps_load_thyself (field));
}
field = field->next;
}
return factory;
}
gboolean
gst_pad_eos_func(GstPad *pad)
{
GstElement *element;
GList *pads;
GstPad *srcpad;
gboolean result = TRUE, success;
g_return_val_if_fail (pad != NULL, FALSE);
g_return_val_if_fail (GST_IS_REAL_PAD(pad), FALSE); // NOTE the restriction
GST_INFO (GST_CAT_PADS,"attempting to set EOS on sink pad %s:%s",GST_DEBUG_PAD_NAME(pad));
element = GST_ELEMENT(gst_pad_get_parent (pad));
// g_return_val_if_fail (element != NULL, FALSE);
// g_return_val_if_fail (GST_IS_ELEMENT(element), FALSE);
pads = gst_element_get_pad_list(element);
while (pads) {
srcpad = GST_PAD(pads->data);
pads = g_list_next(pads);
if (gst_pad_get_direction(srcpad) == GST_PAD_SRC) {
result = gst_pad_eos(GST_REAL_PAD(srcpad));
if (result == FALSE) success = FALSE;
}
}
if (result == FALSE) return FALSE;
GST_INFO (GST_CAT_PADS,"set EOS on sink pad %s:%s",GST_DEBUG_PAD_NAME(pad));
GST_FLAG_SET (pad, GST_PAD_EOS);
return TRUE;
}
/**
* gst_pad_set_eos:
* @pad: the pad to set to eos
*
* Sets the given pad to the EOS state.
*
* Returns: TRUE if it succeeded
*/
gboolean
gst_pad_set_eos(GstPad *pad)
{
g_return_val_if_fail (pad != NULL, FALSE);
g_return_val_if_fail (GST_IS_REAL_PAD(pad), FALSE); // NOTE the restriction
g_return_val_if_fail (GST_PAD_CONNECTED(pad), FALSE);
GST_INFO (GST_CAT_PADS,"attempting to set EOS on src pad %s:%s",GST_DEBUG_PAD_NAME(pad));
gst_element_announce_eos (GST_ELEMENT (pad->parent), TRUE);
if (!gst_pad_eos(GST_REAL_PAD(pad))) {
gst_element_announce_eos (GST_ELEMENT (pad->parent), FALSE);
return FALSE;
}
GST_INFO (GST_CAT_PADS,"set EOS on src pad %s:%s",GST_DEBUG_PAD_NAME(pad));
GST_FLAG_SET (pad, GST_PAD_EOS);
gst_element_signal_eos (GST_ELEMENT (pad->parent));
return TRUE;
}
/*
GstPad *
gst_pad_select(GstPad *nextpad, ...) {
va_list args;
GstPad *pad;
GSList *pads = NULL;
// construct the list of pads
va_start (args, nextpad);
while ((pad = va_arg (args, GstPad*)))
pads = g_slist_prepend (pads, pad);
va_end (args);
// now switch to the nextpad
*/
void
gst_pad_set_element_private (GstPad *pad, gpointer priv)
{
pad->element_private = priv;
}
gpointer
gst_pad_get_element_private (GstPad *pad)
{
return pad->element_private;
}
/***** ghost pads *****/
static void gst_ghost_pad_class_init (GstGhostPadClass *klass);
static void gst_ghost_pad_init (GstGhostPad *pad);
static GstPad *ghost_pad_parent_class = NULL;
//static guint gst_ghost_pad_signals[LAST_SIGNAL] = { 0 };
GtkType
gst_ghost_pad_get_type(void) {
static GtkType pad_type = 0;
if (!pad_type) {
static const GtkTypeInfo pad_info = {
"GstGhostPad",
sizeof(GstGhostPad),
sizeof(GstGhostPadClass),
(GtkClassInitFunc)gst_ghost_pad_class_init,
(GtkObjectInitFunc)gst_ghost_pad_init,
(GtkArgSetFunc)NULL,
(GtkArgGetFunc)NULL,
(GtkClassInitFunc)NULL,
};
pad_type = gtk_type_unique(GST_TYPE_PAD,&pad_info);
}
return pad_type;
}
static void
gst_ghost_pad_class_init (GstGhostPadClass *klass)
{
GtkObjectClass *gtkobject_class;
gtkobject_class = (GtkObjectClass*)klass;
ghost_pad_parent_class = gtk_type_class(GST_TYPE_PAD);
}
static void
gst_ghost_pad_init (GstGhostPad *pad)
{
pad->realpad = NULL;
}
Reference in a new issue View git blame Copy permalink