mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-10-03 01:02:19 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/gstpad.c
Wim Taymans b2ee38575d Landed the new improved capsnegotiation system. 
Original commit message from CVS:
Landed the new improved capsnegotiation system.
The main idea is to keep track of the possible data types that can
pass through a connection. plugins can at any time inspect, adjust and
refine these caps. plugins also get notified when something changes to
the types so that they can reconfigure themselves.
Look at the updated plugins and the soon to be finished doc.
2002-01-13 22:22:42 +00:00

2129 lines
56 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 "gstutils.h"
#include "gstelement.h"
#include "gsttype.h"
#include "gstbin.h"
#include "gstscheduler.h"
#include "gstevent.h"
GType _gst_pad_type = 0;
/***** Start with the base GstPad class *****/
static void gst_pad_class_init (GstPadClass *klass);
static void gst_pad_init (GstPad *pad);
static gboolean gst_pad_try_reconnect_filtered_func (GstPad *pad, GstCaps *caps, gboolean clear);
#ifndef GST_DISABLE_LOADSAVE
static xmlNodePtr gst_pad_save_thyself (GstObject *object, xmlNodePtr parent);
#endif
static GstObject *pad_parent_class = NULL;
GType
gst_pad_get_type(void)
{
if (!_gst_pad_type) {
static const GTypeInfo pad_info = {
sizeof(GstPadClass),
NULL,
NULL,
(GClassInitFunc)gst_pad_class_init,
NULL,
NULL,
sizeof(GstPad),
32,
(GInstanceInitFunc)gst_pad_init,
NULL
};
_gst_pad_type = g_type_register_static(GST_TYPE_OBJECT, "GstPad", &pad_info, 0);
}
return _gst_pad_type;
}
static void
gst_pad_class_init (GstPadClass *klass)
{
pad_parent_class = g_type_class_ref(GST_TYPE_OBJECT);
}
static void
gst_pad_init (GstPad *pad)
{
pad->element_private = NULL;
pad->padtemplate = NULL;
}
/***** Then do the Real Pad *****/
/* Pad signals and args */
enum {
REAL_SET_ACTIVE,
REAL_CAPS_CHANGED,
REAL_CAPS_NEGO_FAILED,
REAL_CONNECTED,
REAL_DISCONNECTED,
REAL_EVENT_RECEIVED,
/* FILL ME */
REAL_LAST_SIGNAL
};
enum {
REAL_ARG_0,
REAL_ARG_ACTIVE,
/* FILL ME */
};
static void gst_real_pad_class_init (GstRealPadClass *klass);
static void gst_real_pad_init (GstRealPad *pad);
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);
static void gst_real_pad_dispose (GObject *object);
static void gst_pad_push_func (GstPad *pad, GstBuffer *buf);
GType _gst_real_pad_type = 0;
static GstPad *real_pad_parent_class = NULL;
static guint gst_real_pad_signals[REAL_LAST_SIGNAL] = { 0 };
GType
gst_real_pad_get_type(void) {
if (!_gst_real_pad_type) {
static const GTypeInfo pad_info = {
sizeof(GstRealPadClass),
NULL,
NULL,
(GClassInitFunc)gst_real_pad_class_init,
NULL,
NULL,
sizeof(GstRealPad),
32,
(GInstanceInitFunc)gst_real_pad_init,
NULL
};
_gst_real_pad_type = g_type_register_static(GST_TYPE_PAD, "GstRealPad", &pad_info, 0);
}
return _gst_real_pad_type;
}
static void
gst_real_pad_class_init (GstRealPadClass *klass)
{
GObjectClass *gobject_class;
GstObjectClass *gstobject_class;
gobject_class = (GObjectClass*) klass;
gstobject_class = (GstObjectClass*) klass;
real_pad_parent_class = g_type_class_ref (GST_TYPE_PAD);
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_real_pad_dispose);
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_real_pad_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_real_pad_get_property);
gst_real_pad_signals[REAL_SET_ACTIVE] =
g_signal_new ("set_active", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstRealPadClass, set_active), NULL, NULL,
gst_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1,
G_TYPE_BOOLEAN);
gst_real_pad_signals[REAL_CAPS_CHANGED] =
g_signal_new ("caps_changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstRealPadClass, caps_changed), NULL, NULL,
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
gst_real_pad_signals[REAL_CAPS_NEGO_FAILED] =
g_signal_new ("caps_nego_failed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstRealPadClass, caps_nego_failed), NULL, NULL,
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
gst_real_pad_signals[REAL_CONNECTED] =
g_signal_new ("connected", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstRealPadClass, connected), NULL, NULL,
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
gst_real_pad_signals[REAL_DISCONNECTED] =
g_signal_new ("disconnected", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstRealPadClass, disconnected), NULL, NULL,
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
gst_real_pad_signals[REAL_EVENT_RECEIVED] =
g_signal_new ("event_received", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstRealPadClass, event_received), NULL, NULL,
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
/* gtk_object_add_arg_type ("GstRealPad::active", G_TYPE_BOOLEAN, */
/* GTK_ARG_READWRITE, REAL_ARG_ACTIVE); */
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));
#ifndef GST_DISABLE_LOADSAVE
gstobject_class->save_thyself = GST_DEBUG_FUNCPTR (gst_pad_save_thyself);
#endif
gstobject_class->path_string_separator = ".";
}
static void
gst_real_pad_init (GstRealPad *pad)
{
pad->direction = GST_PAD_UNKNOWN;
pad->peer = NULL;
pad->sched = NULL;
pad->sched_private = NULL;
pad->chainfunc = NULL;
pad->getfunc = NULL;
pad->getregionfunc = NULL;
pad->chainhandler = GST_DEBUG_FUNCPTR (gst_pad_push_func);
pad->gethandler = NULL;
pad->pullregionfunc = NULL;
pad->bufferpoolfunc = NULL;
pad->ghostpads = NULL;
pad->caps = NULL;
pad->connectfunc = NULL;
pad->getcapsfunc = NULL;
}
static void
gst_real_pad_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
g_return_if_fail (GST_IS_PAD (object));
switch (prop_id) {
case REAL_ARG_ACTIVE:
if (g_value_get_boolean (value)) {
GST_DEBUG (GST_CAT_PADS, "activating pad %s:%s\n", GST_DEBUG_PAD_NAME (object));
GST_FLAG_UNSET (object, GST_PAD_DISABLED);
} else {
GST_DEBUG (GST_CAT_PADS, "de-activating pad %s:%s\n", GST_DEBUG_PAD_NAME (object));
GST_FLAG_SET (object, GST_PAD_DISABLED);
}
g_signal_emit (G_OBJECT (object), gst_real_pad_signals[REAL_SET_ACTIVE], 0,
!GST_FLAG_IS_SET (object, GST_PAD_DISABLED));
break;
default:
break;
}
}
static void
gst_real_pad_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_PAD (object));
switch (prop_id) {
case REAL_ARG_ACTIVE:
g_value_set_boolean (value, !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)
{
GstRealPad *pad;
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (direction != GST_PAD_UNKNOWN, NULL);
pad = g_object_new (gst_real_pad_get_type (), NULL);
gst_object_set_name (GST_OBJECT (pad), name);
GST_RPAD_DIRECTION (pad) = direction;
return GST_PAD (pad);
}
/**
* gst_pad_new_from_template:
* @templ: 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;
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (templ != NULL, NULL);
pad = gst_pad_new (name, templ->direction);
gst_object_ref (GST_OBJECT (templ));
GST_PAD_PADTEMPLATE (pad) = 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_PAD (pad), GST_PAD_UNKNOWN);
return GST_PAD_DIRECTION (pad);
}
/**
* 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));
gst_object_set_name (GST_OBJECT (pad), 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 GST_OBJECT_NAME (pad);
}
/**
* 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_RPAD_CHAINFUNC(pad) = chain;
GST_DEBUG (GST_CAT_PADS, "chainfunc for %s:%s set to %s\n",
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (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));
GST_RPAD_GETFUNC(pad) = get;
GST_DEBUG (GST_CAT_PADS, "getfunc for %s:%s set to %s\n",
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (get));
}
/**
* 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));
}
/**
* 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_RPAD_GETREGIONFUNC(pad) = getregion;
GST_DEBUG (GST_CAT_PADS, "getregionfunc for %s:%s set to %s\n",
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (getregion));
}
/**
* gst_pad_set_connect_function:
* @pad: the pad to set the connect function for
* @connect: the connect function
*
* Set the given connect function for the pad. It will be called
* when the pad is connected or reconnected with caps.
*/
void
gst_pad_set_connect_function (GstPad *pad,
GstPadConnectFunction connect)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad));
GST_RPAD_CONNECTFUNC (pad) = connect;
GST_DEBUG (GST_CAT_PADS, "connectfunc for %s:%s set to %s\n",
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (connect));
}
/**
* gst_pad_set_getcaps_function:
* @pad: the pad to set the getcaps function for
* @getcaps: the getcaps function
*
* Set the given getcaps function for the pad.
*/
void
gst_pad_set_getcaps_function (GstPad *pad,
GstPadGetCapsFunction getcaps)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_REAL_PAD (pad));
GST_RPAD_GETCAPSFUNC (pad) = getcaps;
GST_DEBUG (GST_CAT_PADS, "getcapsfunc for %s:%s set to %s\n",
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (getcaps));
}
/**
* gst_pad_set_bufferpool_function:
* @pad: the pad to set the bufferpool function for
* @bufpool: the bufferpool function
*
* 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));
GST_RPAD_BUFFERPOOLFUNC (pad) = bufpool;
GST_DEBUG (GST_CAT_PADS, "bufferpoolfunc for %s:%s set to %s\n",
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (bufpool));
}
static void
gst_pad_push_func(GstPad *pad, GstBuffer *buf)
{
if (GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad)) != NULL) {
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function %s\n",
GST_DEBUG_FUNCPTR_NAME (GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad))));
(GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad))) (pad, buf);
} else {
GST_DEBUG (GST_CAT_DATAFLOW, "default pad_push handler in place, no chain function\n");
g_warning ("(internal error) default pad_push in place for pad %s:%s but it has no chain function",
GST_DEBUG_PAD_NAME (pad));
}
}
/**
* 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));
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);
/* now we need to deal with the real/ghost stuff */
realsrc = GST_PAD_REALIZE (srcpad);
realsink = GST_PAD_REALIZE (sinkpad);
g_return_if_fail (GST_RPAD_PEER (realsrc) != NULL);
g_return_if_fail (GST_RPAD_PEER (realsink) != NULL);
if ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SINK) &&
(GST_RPAD_DIRECTION (realsink) == GST_PAD_SRC)) {
GstRealPad *temppad;
temppad = realsrc;
realsrc = realsink;
realsink = temppad;
}
g_return_if_fail ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SRC) &&
(GST_RPAD_DIRECTION (realsink) == GST_PAD_SINK));
/* first clear peers */
GST_RPAD_PEER (realsrc) = NULL;
GST_RPAD_PEER (realsink) = NULL;
/* reset the filters, both filters are refcounted once */
if (GST_RPAD_FILTER (realsrc)) {
gst_caps_unref (GST_RPAD_FILTER (realsrc));
GST_RPAD_FILTER (realsink) = NULL;
GST_RPAD_FILTER (realsrc) = NULL;
}
/* 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);
/* fire off a signal to each of the pads telling them that they've been disconnected */
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);
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_filtered:
* @srcpad: the source pad to connect
* @sinkpad: the sink pad to connect
* @filtercaps: the filter caps.
*
* Connects the source pad to the sink pad. The filter indicates the media type
* that should flow trought this connection.
*
* Returns: TRUE if the pad could be connected, FALSE otherwise
*/
gboolean
gst_pad_connect_filtered (GstPad *srcpad, GstPad *sinkpad, GstCaps *filtercaps)
{
GstRealPad *realsrc, *realsink;
gboolean negotiated = FALSE;
/* generic checks */
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);
GST_INFO (GST_CAT_PADS, "connecting %s:%s and %s:%s",
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
/* now we need to deal with the real/ghost stuff */
realsrc = GST_PAD_REALIZE (srcpad);
realsink = GST_PAD_REALIZE (sinkpad);
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));
g_return_val_if_fail (GST_RPAD_PEER (realsrc) == NULL, FALSE);
g_return_val_if_fail (GST_RPAD_PEER (realsink) == NULL, FALSE);
/* check for reversed directions and swap if necessary */
if ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SINK) &&
(GST_RPAD_DIRECTION (realsink) == GST_PAD_SRC)) {
GstRealPad *temppad;
temppad = realsrc;
realsrc = realsink;
realsink = temppad;
}
g_return_val_if_fail ((GST_RPAD_DIRECTION (realsrc) == GST_PAD_SRC) &&
(GST_RPAD_DIRECTION (realsink) == GST_PAD_SINK), FALSE);
/* first set peers */
GST_RPAD_PEER (realsrc) = realsink;
GST_RPAD_PEER (realsink) = realsrc;
if (!gst_pad_try_reconnect_filtered_func (GST_PAD (realsrc), filtercaps, FALSE)) {
GST_DEBUG (GST_CAT_CAPS, "pads cannot connect\n");
GST_RPAD_PEER (realsrc) = NULL;
GST_RPAD_PEER (realsink) = NULL;
return FALSE;
}
/* fire off a signal to each of the pads telling them that they've been connected */
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);
/* now tell the scheduler(s) */
if (realsrc->sched)
gst_scheduler_pad_connect (realsrc->sched, (GstPad *)realsrc, (GstPad *)realsink);
else if (realsink->sched)
gst_scheduler_pad_connect (realsink->sched, (GstPad *)realsrc, (GstPad *)realsink);
GST_INFO (GST_CAT_PADS, "connected %s:%s and %s:%s",
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
return TRUE;
}
/**
* gst_pad_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, FALSE otherwise
*/
gboolean
gst_pad_connect (GstPad *srcpad, GstPad *sinkpad)
{
return gst_pad_connect_filtered (srcpad, sinkpad, NULL);
}
/**
* 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 (GST_PAD_PARENT (pad) == NULL);
g_return_if_fail (parent != NULL);
g_return_if_fail (GST_IS_OBJECT (parent));
g_return_if_fail ((gpointer)pad != (gpointer)parent);
gst_object_set_parent (GST_OBJECT (pad), parent);
}
/**
* gst_pad_get_parent:
* @pad: the pad to get the parent from
*
* Get the parent object of this pad.
*
* Returns: the parent object
*/
GstElement*
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 GST_PAD_PARENT (pad);
}
/**
* gst_pad_get_padtemplate:
* @pad: the pad to get the padtemplate from
*
* Get the padtemplate object of this pad.
*
* Returns: the padtemplate object
*/
GstPadTemplate*
gst_pad_get_padtemplate (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
return GST_PAD_PADTEMPLATE (pad);
}
/**
* gst_pad_set_sched:
* @pad: the pad to set the scheduler for
* @sched: The scheduler to set
*
* Set the sceduler for the pad
*/
void
gst_pad_set_sched (GstPad *pad, GstScheduler *sched)
{
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
GST_RPAD_SCHED(pad) = sched;
}
/**
* gst_pad_get_sched:
* @pad: the pad to get the scheduler from
*
* Get the scheduler of the pad
*
* Returns: the scheduler of the pad.
*/
GstScheduler*
gst_pad_get_sched (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
return GST_RPAD_SCHED(pad);
}
/**
* 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
* returned, as opposed to the gst_pad_get_parent().
*
* Returns: the parent object
*/
GstElement*
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)));
}
/**
* gst_pad_add_ghost_pad:
* @pad: the pad to set the ghost parent
* @ghostpad: the ghost pad to add
*
* Add a ghost pad to a pad.
*/
void
gst_pad_add_ghost_pad (GstPad *pad,
GstPad *ghostpad)
{
GstRealPad *realpad;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
g_return_if_fail (ghostpad != NULL);
g_return_if_fail (GST_IS_GHOST_PAD (ghostpad));
realpad = GST_PAD_REALIZE (pad);
realpad->ghostpads = g_list_prepend (realpad->ghostpads, ghostpad);
}
/**
* gst_pad_remove_ghost_pad:
* @pad: the pad to remove the ghost parent
* @ghostpad: the ghost pad to remove from the pad
*
* Remove a ghost pad from a pad.
*/
void
gst_pad_remove_ghost_pad (GstPad *pad,
GstPad *ghostpad)
{
GstRealPad *realpad;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
g_return_if_fail (ghostpad != NULL);
g_return_if_fail (GST_IS_GHOST_PAD (ghostpad));
realpad = GST_PAD_REALIZE (pad);
realpad->ghostpads = g_list_remove (realpad->ghostpads, ghostpad);
}
/**
* gst_pad_get_ghost_pad_list:
* @pad: the pad to get the ghost parents from
*
* Get the ghost parents of this pad.
*
* Returns: a GList of ghost pads
*/
GList*
gst_pad_get_ghost_pad_list (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
return GST_PAD_REALIZE(pad)->ghostpads;
}
static GstPadConnectReturn
gst_pad_try_set_caps_func (GstPad *pad, GstCaps *caps, gboolean notify, gboolean set_caps)
{
GstCaps *oldcaps;
GST_INFO (GST_CAT_CAPS, "trying to set caps %p on pad %s:%s",
caps, GST_DEBUG_PAD_NAME (pad));
if (notify && GST_RPAD_CONNECTFUNC (pad)) {
GstPadConnectReturn res;
gchar *debug_string;
GST_INFO (GST_CAT_CAPS, "calling connect function on pad %s:%s",
GST_DEBUG_PAD_NAME (pad));
res = GST_RPAD_CONNECTFUNC (pad) (pad, caps);
switch (res) {
case GST_PAD_CONNECT_REFUSED:
debug_string = "REFUSED";
break;
case GST_PAD_CONNECT_OK:
debug_string = "OK";
break;
case GST_PAD_CONNECT_DONE:
debug_string = "DONE";
break;
case GST_PAD_CONNECT_DELAYED:
debug_string = "DELAYED";
break;
default:
g_warning ("unknown return code from connect function of pad %s:%s",
GST_DEBUG_PAD_NAME (pad));
return GST_PAD_CONNECT_REFUSED;
}
GST_INFO (GST_CAT_CAPS, "got reply %s (%d) from connect function on pad %s:%s",
debug_string, res, GST_DEBUG_PAD_NAME (pad));
if (res == GST_PAD_CONNECT_DONE) {
GST_INFO (GST_CAT_CAPS, "pad %s:%s is done", GST_DEBUG_PAD_NAME (pad));
return GST_PAD_CONNECT_DONE;
}
if (res == GST_PAD_CONNECT_REFUSED) {
GST_INFO (GST_CAT_CAPS, "pad %s:%s doesn't accept caps",
GST_DEBUG_PAD_NAME (pad));
return GST_PAD_CONNECT_REFUSED;
}
}
/* we can only set caps on the pad if they are ficed */
if (GST_CAPS_IS_FIXED (caps)) {
if (set_caps) {
GST_INFO (GST_CAT_CAPS, "setting caps on pad %s:%s",
GST_DEBUG_PAD_NAME (pad));
/* if we got this far all is ok */
oldcaps = GST_PAD_CAPS (pad);
if (caps) gst_caps_ref (caps);
GST_PAD_CAPS (pad) = caps;
if (oldcaps) gst_caps_unref (oldcaps);
}
else {
GST_INFO (GST_CAT_CAPS, "NOT setting caps on pad %s:%s, as requested",
GST_DEBUG_PAD_NAME (pad));
}
}
else {
GST_INFO (GST_CAT_CAPS, "caps are not fixed on pad %s:%s, not setting them yet",
GST_DEBUG_PAD_NAME (pad));
}
return GST_PAD_CONNECT_OK;
}
gboolean
gst_pad_try_set_caps (GstPad *pad, GstCaps *caps)
{
GstCaps *oldcaps;
GstPad *peer;
peer = GST_PAD (GST_RPAD_PEER (pad));
GST_INFO (GST_CAT_CAPS, "trying to set caps %p on pad %s:%s",
caps, GST_DEBUG_PAD_NAME (pad));
if (!GST_CAPS_IS_FIXED (caps)) {
g_warning ("trying to set non fixed caps on pad %s:%s, caps dump follow",
GST_DEBUG_PAD_NAME (pad));
gst_caps_debug (caps);
return FALSE;
}
if (peer && !gst_pad_try_set_caps_func (peer, caps, TRUE, TRUE))
return FALSE;
if (!gst_pad_try_set_caps_func (pad, caps, FALSE, TRUE))
return FALSE;
return TRUE;
}
static gboolean
gst_pad_try_reconnect_filtered_func (GstPad *pad, GstCaps *filtercaps, gboolean clear)
{
GstCaps *srccaps, *sinkcaps;
GstCaps *intersection = NULL;
GstRealPad *realsrc, *realsink;
g_return_val_if_fail (pad != NULL, FALSE);
realsrc = GST_PAD_REALIZE (pad);
realsink = GST_PAD_REALIZE (GST_RPAD_PEER (realsrc));
g_return_val_if_fail (GST_RPAD_PEER (realsrc) != NULL, FALSE);
g_return_val_if_fail (GST_RPAD_PEER (realsink) != NULL, FALSE);
GST_INFO (GST_CAT_PADS, "reconnect filtered %s:%s and %s:%s",
GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
if (clear) {
GST_INFO (GST_CAT_PADS, "reconnect filtered %s:%s and %s:%s, clearing caps",
GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
GST_PAD_CAPS (GST_PAD (realsrc)) = NULL;
GST_PAD_CAPS (GST_PAD (realsink)) = NULL;
}
srccaps = gst_pad_get_caps (GST_PAD (realsrc));
GST_INFO (GST_CAT_PADS, "dumping caps of pad %s:%s", GST_DEBUG_PAD_NAME (realsrc));
gst_caps_debug (srccaps);
sinkcaps = gst_pad_get_caps (GST_PAD (realsink));
GST_INFO (GST_CAT_PADS, "dumping caps of pad %s:%s", GST_DEBUG_PAD_NAME (realsink));
gst_caps_debug (sinkcaps);
intersection = gst_caps_intersect (srccaps, sinkcaps);
/* if we have no intersection but one of the caps was not NULL.. */
if (!intersection && (srccaps || sinkcaps )) {
/* the intersection is NULL, this means they have no common format */
GST_INFO (GST_CAT_PADS, "pads %s:%s and %s:%s have no common type",
GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
return FALSE;
}
else {
GST_INFO (GST_CAT_PADS, "pads %s:%s and %s:%s intersected to %s caps",
GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink),
((intersection && GST_CAPS_IS_FIXED (intersection)) ? "fixed" : "variable"));
if (filtercaps) {
GstCaps *filtered_intersection = gst_caps_intersect (intersection, filtercaps);
/* get rid of the old intersection here */
gst_caps_unref (intersection);
if (!filtered_intersection) {
GST_INFO (GST_CAT_PADS, "filtered connection between pads %s:%s and %s:%s is empty, disconnecting",
GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
return FALSE;
}
intersection = filtered_intersection;
GST_RPAD_APPFILTER (realsink) = filtercaps;
GST_RPAD_APPFILTER (realsrc) = filtercaps;
}
}
GST_DEBUG (GST_CAT_CAPS, "setting filter for connection to:\n");
gst_caps_debug (intersection);
GST_RPAD_FILTER (realsrc) = intersection;
GST_RPAD_FILTER (realsink) = intersection;
if (intersection) {
GstPadConnectReturn res;
res = gst_pad_try_set_caps_func (GST_PAD (realsrc), intersection, TRUE, TRUE);
if (res == GST_PAD_CONNECT_REFUSED)
return FALSE;
if (res == GST_PAD_CONNECT_DONE)
return TRUE;
res = gst_pad_try_set_caps_func (GST_PAD (realsink), intersection, TRUE, TRUE);
if (res == GST_PAD_CONNECT_REFUSED)
return FALSE;
if (res == GST_PAD_CONNECT_DONE)
return TRUE;
}
return TRUE;
}
/**
* gst_pad_try_reconnect_filtered:
* @pad: the pad to reconnect
* @caps: the capabilities to use in the reconnectiong
*
* Try to reconnect this pad and its peer with the specified caps
*
* Returns: a boolean indicating the peer pad could accept the caps.
*/
gboolean
gst_pad_try_reconnect_filtered (GstPad *pad, GstCaps *filtercaps)
{
g_return_val_if_fail (pad != NULL, FALSE);
g_return_val_if_fail (GST_IS_REAL_PAD (pad), FALSE);
g_return_val_if_fail (GST_PAD_IS_CONNECTED (pad), FALSE);
return gst_pad_try_reconnect_filtered_func (pad, filtercaps, TRUE);
}
/**
* gst_pad_reconnect_filtered:
* @pad: the pad to reconnect
* @caps: the capabilities to use in the reconnectiong
*
* Try to reconnect this pad and its peer with the specified caps.
*
* Returns: a boolean indicating the peer pad could accept the caps.
* if FALSE is returned, the pads are disconnected.
*/
gboolean
gst_pad_reconnect_filtered (GstPad *pad, GstCaps *filtercaps)
{
g_return_val_if_fail (pad != NULL, FALSE);
g_return_val_if_fail (GST_IS_REAL_PAD (pad), FALSE);
g_return_val_if_fail (GST_PAD_IS_CONNECTED (pad), FALSE);
if (!gst_pad_try_reconnect_filtered_func (pad, filtercaps, TRUE)) {
gst_pad_disconnect (pad, GST_PAD (GST_PAD_PEER (pad)));
return FALSE;
}
return TRUE;
}
/**
* gst_pad_proxy_connect:
* @pad: the pad to proxy to
* @caps: the capabilities to use in the proxying
*
* Proxy the connect function to the specified pad.
*
* Returns: a boolean indicating the peer pad could accept the caps.
*/
GstPadConnectReturn
gst_pad_proxy_connect (GstPad *pad, GstCaps *caps)
{
GstPad *peer;
peer = GST_PAD (GST_RPAD_PEER (pad));
GST_INFO (GST_CAT_CAPS, "proxy connect to pad %s:%s",
GST_DEBUG_PAD_NAME (pad));
if (peer && !gst_pad_try_set_caps_func (peer, caps, TRUE, TRUE))
return GST_PAD_CONNECT_REFUSED;
if (!gst_pad_try_set_caps_func (pad, caps, FALSE, TRUE))
return GST_PAD_CONNECT_REFUSED;
return GST_PAD_CONNECT_OK;
}
/**
* gst_pad_get_caps:
* @pad: the pad to get the capabilities from
*
* Get the capabilities of this pad.
*
* Returns: the capabilities of this pad
*/
GstCaps*
gst_pad_get_caps (GstPad *pad)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
GST_DEBUG (GST_CAT_CAPS, "get pad caps of %s:%s (%p)\n",
GST_DEBUG_PAD_NAME (pad), pad);
if (GST_PAD_CAPS (pad)) {
GST_DEBUG (GST_CAT_CAPS, "using pad real caps\n");
return GST_PAD_CAPS (pad);
}
else if GST_RPAD_GETCAPSFUNC (pad) {
GST_DEBUG (GST_CAT_CAPS, "using pad get function\n");
return GST_RPAD_GETCAPSFUNC (pad) (pad, NULL);
}
else if (GST_PAD_PADTEMPLATE (pad)) {
GST_DEBUG (GST_CAT_CAPS, "using pad template\n");
return GST_PADTEMPLATE_CAPS (GST_PAD_PADTEMPLATE (pad));
}
GST_DEBUG (GST_CAT_CAPS, "pad has no caps\n");
return NULL;
}
/**
* 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
*/
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;
}
/**
* gst_padtemplate_get_caps_by_name:
* @templ: the padtemplate to get the capabilities from
* @name: the name of the capability to get
*
* Get the capability with the given name from this padtemplate.
*
* Returns: a capability or NULL if not found
*/
GstCaps*
gst_padtemplate_get_caps_by_name (GstPadTemplate *templ, const gchar *name)
{
GstCaps *caps;
g_return_val_if_fail (templ != NULL, NULL);
caps = GST_PADTEMPLATE_CAPS (templ);
if (!caps)
return NULL;
return gst_caps_get_by_name (caps, name);
}
/**
* 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)
{
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);
if (GST_PAD_CAPS (srcpad) && GST_PAD_CAPS (sinkpad)) {
if (!gst_caps_check_compatibility (GST_PAD_CAPS (srcpad), GST_PAD_CAPS (sinkpad))) {
return FALSE;
}
else {
return TRUE;
}
}
else {
GST_DEBUG (GST_CAT_PADS, "could not check capabilities of pads (%s:%s) and (%s:%s) %p %p\n",
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad),
GST_PAD_CAPS (srcpad), GST_PAD_CAPS (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)
{
g_return_val_if_fail (pad != NULL, NULL);
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
return GST_PAD (GST_PAD_PEER (pad));
}
/**
* gst_pad_get_allowed_caps:
* @pad: the pad to get the allowed caps from
*
* Gst the caps of the allowed media types that can
* go through this pad.
*
* Returns: the allowed caps
*/
GstCaps*
gst_pad_get_allowed_caps (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);
GST_DEBUG (GST_CAT_PROPERTIES, "get allowed caps of %s:%s\n", GST_DEBUG_PAD_NAME (pad));
/* this is not very correct: ...
if (peer && GST_RPAD_GETCAPSFUNC (peer)) {
GST_DEBUG (GST_CAT_PROPERTIES, "using getcaps function of peer %s:%s\n",
GST_DEBUG_PAD_NAME (peer));
return GST_RPAD_GETCAPSFUNC (peer) (GST_PAD (peer), NULL);
}
*/
return gst_caps_copy (GST_RPAD_FILTER (pad));
}
/**
* gst_pad_get_allowed_caps:
* @pad: the pad to get the allowed caps from
*
* Gst the caps of the allowed media types that can
* go through this pad.
*
* Returns: the allowed caps
*/
gboolean
gst_pad_recalc_allowed_caps (GstPad *pad)
{
GstRealPad *peer;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
GST_DEBUG (GST_CAT_PROPERTIES, "set allowed caps of %s:%s\n", GST_DEBUG_PAD_NAME (pad));
peer = GST_RPAD_PEER (pad);
if (peer)
gst_pad_try_reconnect_filtered (pad, GST_RPAD_APPFILTER (pad));
}
/**
* gst_pad_get_bufferpool:
* @pad: the pad to get the bufferpool from
*
* Get the bufferpool of the peer pad of the given
* pad
*
* Returns: The GstBufferPool or NULL.
*/
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);
if (!peer)
return NULL;
GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
if (peer->bufferpoolfunc) {
GST_DEBUG (GST_CAT_PADS, "calling bufferpoolfunc &%s (@%p) of peer pad %s:%s\n",
GST_DEBUG_FUNCPTR_NAME (peer->bufferpoolfunc), &peer->bufferpoolfunc, GST_DEBUG_PAD_NAME (((GstPad*) peer)));
return (peer->bufferpoolfunc) (((GstPad*) peer));
} else {
GST_DEBUG (GST_CAT_PADS, "no bufferpoolfunc for peer pad %s:%s at %p\n",
GST_DEBUG_PAD_NAME (((GstPad*) peer)), &peer->bufferpoolfunc);
return NULL;
}
}
static void
gst_real_pad_dispose (GObject *object)
{
GstPad *pad = GST_PAD (object);
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose %s:%s\n", GST_DEBUG_PAD_NAME(pad));
if (GST_PAD (pad)->padtemplate){
GST_DEBUG (GST_CAT_REFCOUNTING, "unreffing padtemplate'%s'\n",GST_OBJECT_NAME(GST_OBJECT (GST_PAD (pad)->padtemplate)));
gst_object_unref (GST_OBJECT (GST_PAD (pad)->padtemplate));
}
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)))));
gst_pad_disconnect (pad, GST_PAD (GST_PAD_PEER (pad)));
}
/* we destroy the ghostpads, because they are nothing without the real pad */
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);
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)));
gst_element_remove_ghost_pad (GST_ELEMENT (GST_OBJECT_PARENT (ghostpad)), GST_PAD (ghostpad));
}
ghostpads = g_list_next (ghostpads);
}
g_list_free (orig);
g_list_free (GST_REAL_PAD(pad)->ghostpads);
}
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);
}
G_OBJECT_CLASS (real_pad_parent_class)->dispose (object);
}
#ifndef GST_DISABLE_LOADSAVE
/**
* gst_pad_load_and_connect:
* @self: the XML node to read the description from
* @parent: the element that has the pad
*
* Read the pad definition from the XML node and connect the given pad
* in element to a pad of an element up in the hierarchy.
*/
void
gst_pad_load_and_connect (xmlNodePtr self,
GstObject *parent)
{
xmlNodePtr field = self->xmlChildrenNode;
GstPad *pad = NULL, *targetpad;
guchar *peer = NULL;
gchar **split;
GstElement *target;
GstObject *grandparent;
while (field) {
if (!strcmp (field->name, "name")) {
pad = gst_element_get_pad (GST_ELEMENT (parent), xmlNodeGetContent (field));
}
else if (!strcmp(field->name, "peer")) {
peer = 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);
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;
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
*/
static xmlNodePtr
gst_pad_save_thyself (GstObject *object,
xmlNodePtr parent)
{
GstRealPad *realpad;
GstPad *peer;
g_return_val_if_fail (GST_IS_REAL_PAD (object), NULL);
realpad = GST_REAL_PAD(object);
xmlNewChild(parent,NULL,"name", GST_PAD_NAME (realpad));
if (GST_RPAD_PEER(realpad) != NULL) {
peer = GST_PAD(GST_RPAD_PEER(realpad));
/* first check to see if the peer's parent's parent is the same */
/* we just save it off */
xmlNewChild(parent,NULL,"peer",g_strdup_printf("%s.%s",
GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer)));
} 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;
g_return_val_if_fail (GST_IS_GHOST_PAD (pad), NULL);
self = xmlNewChild(parent,NULL,"ghostpad",NULL);
xmlNewChild(self,NULL,"name", GST_PAD_NAME (pad));
xmlNewChild(self,NULL,"parent", GST_OBJECT_NAME (GST_PAD_PARENT (pad)));
/* FIXME FIXME FIXME! */
return self;
}
#endif /* GST_DISABLE_LOADSAVE */
#ifndef gst_pad_push
/**
* 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));
g_return_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SRC);
if (!peer) {
g_warning ("push on pad %s:%s but it is unconnected", GST_DEBUG_PAD_NAME (pad));
}
else {
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
gst_event_free (GST_EVENT (buf));
}
}
#endif
#ifndef gst_pad_pull
/**
* 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)
{
GstRealPad *peer = GST_RPAD_PEER(pad);
GST_DEBUG_ENTER("(%s:%s)",GST_DEBUG_PAD_NAME(pad));
g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
if (!peer) {
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);
}
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);
}
}
return NULL;
}
#endif
#ifndef gst_pad_pullregion
/**
* 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)
{
GstRealPad *peer;
GstBuffer *result = NULL;
g_return_val_if_fail (GST_PAD_DIRECTION (pad) == GST_PAD_SINK, NULL);
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);
if (peer->pullregionfunc) {
GST_DEBUG (GST_CAT_DATAFLOW, "calling pullregionfunc &%s of peer pad %s:%s\n",
GST_DEBUG_FUNCPTR_NAME (peer->pullregionfunc), GST_DEBUG_PAD_NAME(GST_PAD_CAST (peer)));
result = (peer->pullregionfunc) (GST_PAD_CAST (peer), type, offset, len);
} else {
GST_DEBUG (GST_CAT_DATAFLOW,"no pullregionfunc\n");
result = NULL;
break;
}
}
/* FIXME */
while (result && !(GST_BUFFER_OFFSET (result) == offset &&
GST_BUFFER_SIZE (result) == len));
return result;
}
#endif
/**
* 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)
{
GstPad *pad;
pad = gst_scheduler_pad_select (GST_PAD_PARENT (padlist->data)->sched, padlist);
return pad;
}
/**
* 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;
}
/************************************************************************
*
* templates
*
*/
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 };
GType
gst_padtemplate_get_type (void)
{
static GType padtemplate_type = 0;
if (!padtemplate_type) {
static const GTypeInfo padtemplate_info = {
sizeof(GstPadTemplateClass),
NULL,
NULL,
(GClassInitFunc)gst_padtemplate_class_init,
NULL,
NULL,
sizeof(GstPadTemplate),
32,
(GInstanceInitFunc)gst_padtemplate_init,
NULL
};
padtemplate_type = g_type_register_static(GST_TYPE_OBJECT, "GstPadTemplate", &padtemplate_info, 0);
}
return padtemplate_type;
}
static void
gst_padtemplate_class_init (GstPadTemplateClass *klass)
{
GObjectClass *gobject_class;
GstObjectClass *gstobject_class;
gobject_class = (GObjectClass*)klass;
gstobject_class = (GstObjectClass*)klass;
padtemplate_parent_class = g_type_class_ref(GST_TYPE_OBJECT);
gst_padtemplate_signals[TEMPL_PAD_CREATED] =
g_signal_new ("pad_created", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstPadTemplateClass, pad_created), NULL, NULL,
gst_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
gstobject_class->path_string_separator = "*";
}
static void
gst_padtemplate_init (GstPadTemplate *templ)
{
}
/**
* gst_padtemplate_new:
* @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
* @...: more capabilities
*
* Creates a new padtemplate from the given arguments.
*
* Returns: the new padtemplate
*/
GstPadTemplate*
gst_padtemplate_new (gchar *name_template,
GstPadDirection direction, GstPadPresence presence,
GstCaps *caps, ...)
{
GstPadTemplate *new;
va_list var_args;
GstCaps *thecaps = NULL;
g_return_val_if_fail (name_template != NULL, NULL);
new = g_object_new(gst_padtemplate_get_type () ,NULL);
GST_PADTEMPLATE_NAME_TEMPLATE (new) = name_template;
GST_PADTEMPLATE_DIRECTION (new) = direction;
GST_PADTEMPLATE_PRESENCE (new) = presence;
va_start (var_args, caps);
while (caps) {
new->fixed &= caps->fixed;
thecaps = gst_caps_append (thecaps, caps);
caps = va_arg (var_args, GstCaps*);
}
va_end (var_args);
GST_PADTEMPLATE_CAPS (new) = thecaps;
return new;
}
/**
* 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);
}
#ifndef GST_DISABLE_LOADSAVE
/**
* gst_padtemplate_save_thyself:
* @templ: 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 *templ, xmlNodePtr parent)
{
xmlNodePtr subtree;
guchar *presence;
GST_DEBUG (GST_CAT_XML,"saving padtemplate %s\n", templ->name_template);
xmlNewChild(parent,NULL,"nametemplate", templ->name_template);
xmlNewChild(parent,NULL,"direction", (templ->direction == GST_PAD_SINK? "sink":"src"));
switch (templ->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);
if (GST_PADTEMPLATE_CAPS (templ)) {
subtree = xmlNewChild (parent, NULL, "caps", NULL);
gst_caps_save_thyself (GST_PADTEMPLATE_CAPS (templ), subtree);
}
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->xmlChildrenNode;
GstPadTemplate *factory;
gchar *name_template = NULL;
GstPadDirection direction = GST_PAD_UNKNOWN;
GstPadPresence presence = GST_PAD_ALWAYS;
GstCaps *caps = NULL;
while (field) {
if (!strcmp(field->name, "nametemplate")) {
name_template = xmlNodeGetContent(field);
}
if (!strcmp(field->name, "direction")) {
gchar *value = xmlNodeGetContent(field);
if (!strcmp(value, "sink")) {
direction = GST_PAD_SINK;
}
else if (!strcmp(value, "src")) {
direction = GST_PAD_SRC;
}
g_free (value);
}
if (!strcmp(field->name, "presence")) {
gchar *value = xmlNodeGetContent(field);
if (!strcmp(value, "always")) {
presence = GST_PAD_ALWAYS;
}
else if (!strcmp(value, "sometimes")) {
presence = GST_PAD_SOMETIMES;
}
else if (!strcmp(value, "request")) {
presence = GST_PAD_REQUEST;
}
g_free (value);
}
else if (!strcmp(field->name, "caps")) {
caps = gst_caps_load_thyself (field);
}
field = field->next;
}
factory = gst_padtemplate_new (name_template, direction, presence, caps, NULL);
return factory;
}
#endif /* !GST_DISABLE_LOADSAVE */
/**
* 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.
*/
void
gst_pad_set_element_private (GstPad *pad, gpointer priv)
{
pad->element_private = priv;
}
/**
* 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.
*/
gpointer
gst_pad_get_element_private (GstPad *pad)
{
return pad->element_private;
}
/***** ghost pads *****/
GType _gst_ghost_pad_type = 0;
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 }; */
GType
gst_ghost_pad_get_type(void) {
if (!_gst_ghost_pad_type) {
static const GTypeInfo pad_info = {
sizeof(GstGhostPadClass),
NULL,
NULL,
(GClassInitFunc)gst_ghost_pad_class_init,
NULL,
NULL,
sizeof(GstGhostPad),
8,
(GInstanceInitFunc)gst_ghost_pad_init,
NULL
};
_gst_ghost_pad_type = g_type_register_static(GST_TYPE_PAD, "GstGhostPad", &pad_info, 0);
}
return _gst_ghost_pad_type;
}
static void
gst_ghost_pad_class_init (GstGhostPadClass *klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass*)klass;
ghost_pad_parent_class = g_type_class_ref(GST_TYPE_PAD);
}
static void
gst_ghost_pad_init (GstGhostPad *pad)
{
pad->realpad = NULL;
}
/**
* 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);
ghostpad = g_object_new (gst_ghost_pad_get_type () ,NULL);
gst_pad_set_name (GST_PAD (ghostpad), name);
GST_GPAD_REALPAD (ghostpad) = GST_PAD_REALIZE (pad);
GST_PAD_PADTEMPLATE (ghostpad) = GST_PAD_PADTEMPLATE (pad);
/* add ourselves to the real pad's list of ghostpads */
gst_pad_add_ghost_pad (pad, GST_PAD (ghostpad));
/* FIXME need to ref the real pad here... ? */
GST_DEBUG (GST_CAT_PADS, "created ghost pad \"%s\"\n", name);
return GST_PAD (ghostpad);
}
static void
gst_pad_event_default_dispatch (GstPad *pad, GstElement *element, GstEvent *event)
{
GList *pads = element->pads;
while (pads) {
GstPad *eventpad = GST_PAD (pads->data);
pads = g_list_next (pads);
/* for all pads in the opposite direction that are connected */
if (GST_PAD_DIRECTION (eventpad) != GST_PAD_DIRECTION (pad) && GST_PAD_IS_CONNECTED (eventpad)) {
if (GST_PAD_DIRECTION (eventpad) == GST_PAD_SRC) {
gst_pad_push (eventpad, GST_BUFFER (gst_event_new (GST_EVENT_TYPE (event))));
}
else {
GstPad *peerpad = GST_PAD_CAST (GST_RPAD_PEER (eventpad));
gst_pad_send_event (peerpad, gst_event_new (GST_EVENT_TYPE (event)));
}
}
}
}
/**
* gst_pad_event_default:
* @pad: the pad to operate on
* @event: the event to handle
*
* Invoke the default event handler for the given pad.
*/
void
gst_pad_event_default (GstPad *pad, GstEvent *event)
{
GstElement *element = GST_PAD_PARENT (pad);
g_signal_emit (G_OBJECT (pad), gst_real_pad_signals[REAL_EVENT_RECEIVED], 0, event);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
gst_element_set_eos (element);
gst_pad_event_default_dispatch (pad, element, event);
gst_event_free (event);
/* we have to try to schedule another element because this one is disabled */
gst_element_yield (element);
break;
case GST_EVENT_FLUSH:
default:
gst_pad_event_default_dispatch (pad, element, event);
gst_event_free (event);
break;
}
}
/**
* 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.
*
* Returns: TRUE if the event was handled.
*/
gboolean
gst_pad_send_event (GstPad *pad, GstEvent *event)
{
gboolean handled = FALSE;
g_return_val_if_fail (event, FALSE);
if (GST_EVENT_SRC (event) == NULL)
GST_EVENT_SRC (event) = gst_object_ref (GST_OBJECT (pad));
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, "proceeding with default event behavior here\n");
gst_pad_event_default (pad, event);
handled = TRUE;
}
return handled;
}
Reference in a new issue View git blame Copy permalink