/* GStreamer * Copyright (C) 1999,2000 Erik Walthinsen * 2000 Wim Taymans * 2005 Andy Wingo * 2006 Edward Hervey * * gstghostpad.c: Proxy pads * * 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., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ /** * SECTION:gstghostpad * @short_description: Pseudo link pads * @see_also: #GstPad * * GhostPads are useful when organizing pipelines with #GstBin like elements. * The idea here is to create hierarchical element graphs. The bin element * contains a sub-graph. Now one would like to treat the bin-element like any * other #GstElement. This is where GhostPads come into play. A GhostPad acts as * a proxy for another pad. Thus the bin can have sink and source ghost-pads * that are associated with sink and source pads of the child elements. * * If the target pad is known at creation time, gst_ghost_pad_new() is the * function to use to get a ghost-pad. Otherwise one can use gst_ghost_pad_new_no_target() * to create the ghost-pad and use gst_ghost_pad_set_target() to establish the * association later on. * * Note that GhostPads add overhead to the data processing of a pipeline. * * Last reviewed on 2005-11-18 (0.9.5) */ #include "gst_private.h" #include "gstinfo.h" #include "gstghostpad.h" #include "gst.h" #define GST_CAT_DEFAULT GST_CAT_PADS #define GST_PROXY_PAD_CAST(obj) ((GstProxyPad *)obj) #define GST_PROXY_PAD_PRIVATE(obj) (GST_PROXY_PAD_CAST (obj)->priv) #define GST_PROXY_PAD_TARGET(pad) (GST_PAD_PEER (GST_PROXY_PAD_INTERNAL (pad))) #define GST_PROXY_PAD_INTERNAL(pad) (GST_PROXY_PAD_PRIVATE (pad)->internal) #define GST_PROXY_PAD_ACQUIRE_INTERNAL(pad, internal, retval) \ internal = \ GST_PAD_CAST (gst_proxy_pad_get_internal (GST_PROXY_PAD_CAST (pad))); \ if (internal == NULL) \ return retval; #define GST_PROXY_PAD_RELEASE_INTERNAL(internal) gst_object_unref (internal); struct _GstProxyPadPrivate { GstPad *internal; }; G_DEFINE_TYPE (GstProxyPad, gst_proxy_pad, GST_TYPE_PAD); static GstPad *gst_proxy_pad_get_target (GstPad * pad); /** * gst_proxy_pad_iterate_internal_links_default: * @pad: the #GstPad to get the internal links of. * @parent: (allow-none): the parent of @pad or NULL * * Invoke the default iterate internal links function of the proxy pad. * * Returns: a #GstIterator of #GstPad, or NULL if @pad has no parent. Unref each * returned pad with gst_object_unref(). */ GstIterator * gst_proxy_pad_iterate_internal_links_default (GstPad * pad, GstObject * parent) { GstIterator *res = NULL; GstPad *internal; GValue v = { 0, }; g_return_val_if_fail (GST_IS_PROXY_PAD (pad), NULL); GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, internal, NULL); g_value_init (&v, GST_TYPE_PAD); g_value_take_object (&v, internal); res = gst_iterator_new_single (GST_TYPE_PAD, &v); g_value_unset (&v); return res; } /** * gst_proxy_pad_chain_default: * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not. * @parent: (allow-none): the parent of @pad or NULL * @buffer: (transfer full): the #GstBuffer to send, return GST_FLOW_ERROR * if not. * * Invoke the default chain function of the proxy pad. * * Returns: a #GstFlowReturn from the pad. */ GstFlowReturn gst_proxy_pad_chain_default (GstPad * pad, GstObject * parent, GstBuffer * buffer) { GstFlowReturn res; GstPad *internal; g_return_val_if_fail (GST_IS_PROXY_PAD (pad), GST_FLOW_ERROR); g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR); GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, internal, GST_FLOW_NOT_LINKED); res = gst_pad_push (internal, buffer); GST_PROXY_PAD_RELEASE_INTERNAL (internal); return res; } /** * gst_proxy_pad_chain_list_default: * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not. * @parent: (allow-none): the parent of @pad or NULL * @list: (transfer full): the #GstBufferList to send, return GST_FLOW_ERROR * if not. * * Invoke the default chain list function of the proxy pad. * * Returns: a #GstFlowReturn from the pad. */ GstFlowReturn gst_proxy_pad_chain_list_default (GstPad * pad, GstObject * parent, GstBufferList * list) { GstFlowReturn res; GstPad *internal; g_return_val_if_fail (GST_IS_PROXY_PAD (pad), GST_FLOW_ERROR); g_return_val_if_fail (GST_IS_BUFFER_LIST (list), GST_FLOW_ERROR); GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, internal, GST_FLOW_NOT_LINKED); res = gst_pad_push_list (internal, list); GST_PROXY_PAD_RELEASE_INTERNAL (internal); return res; } /** * gst_proxy_pad_getrange_default: * @pad: a src #GstPad, returns #GST_FLOW_ERROR if not. * @parent: the parent of @pad * @offset: The start offset of the buffer * @size: The length of the buffer * @buffer: (out callee-allocates): a pointer to hold the #GstBuffer, * returns #GST_FLOW_ERROR if %NULL. * * Invoke the default getrange function of the proxy pad. * * Returns: a #GstFlowReturn from the pad. */ GstFlowReturn gst_proxy_pad_getrange_default (GstPad * pad, GstObject * parent, guint64 offset, guint size, GstBuffer ** buffer) { GstFlowReturn res; GstPad *internal; g_return_val_if_fail (GST_IS_PROXY_PAD (pad), GST_FLOW_ERROR); g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR); GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, internal, GST_FLOW_NOT_LINKED); res = gst_pad_pull_range (internal, offset, size, buffer); GST_PROXY_PAD_RELEASE_INTERNAL (internal); return res; } static GstPad * gst_proxy_pad_get_target (GstPad * pad) { GstPad *target; GST_OBJECT_LOCK (pad); target = GST_PROXY_PAD_TARGET (pad); if (target) gst_object_ref (target); GST_OBJECT_UNLOCK (pad); return target; } /** * gst_proxy_pad_get_internal: * @pad: the #GstProxyPad * * Get the internal pad of @pad. Unref target pad after usage. * * The internal pad of a #GstGhostPad is the internally used * pad of opposite direction, which is used to link to the target. * * Returns: (transfer full): the target #GstProxyPad, can be NULL. * Unref target pad after usage. */ GstProxyPad * gst_proxy_pad_get_internal (GstProxyPad * pad) { GstPad *internal; g_return_val_if_fail (GST_IS_PROXY_PAD (pad), NULL); GST_OBJECT_LOCK (pad); internal = GST_PROXY_PAD_INTERNAL (pad); if (internal) gst_object_ref (internal); GST_OBJECT_UNLOCK (pad); return GST_PROXY_PAD_CAST (internal); } static void gst_proxy_pad_class_init (GstProxyPadClass * klass) { g_type_class_add_private (klass, sizeof (GstProxyPadPrivate)); /* Register common function pointer descriptions */ GST_DEBUG_REGISTER_FUNCPTR (gst_proxy_pad_iterate_internal_links_default); GST_DEBUG_REGISTER_FUNCPTR (gst_proxy_pad_chain_default); GST_DEBUG_REGISTER_FUNCPTR (gst_proxy_pad_chain_list_default); GST_DEBUG_REGISTER_FUNCPTR (gst_proxy_pad_getrange_default); } static void gst_proxy_pad_init (GstProxyPad * ppad) { GstPad *pad = (GstPad *) ppad; GST_PROXY_PAD_PRIVATE (ppad) = G_TYPE_INSTANCE_GET_PRIVATE (ppad, GST_TYPE_PROXY_PAD, GstProxyPadPrivate); gst_pad_set_iterate_internal_links_function (pad, gst_proxy_pad_iterate_internal_links_default); GST_PAD_SET_PROXY_CAPS (pad); GST_PAD_SET_PROXY_SCHEDULING (pad); GST_PAD_SET_PROXY_ALLOCATION (pad); } /*********************************************************************** * Ghost pads, implemented as a pair of proxy pads (sort of) */ #define GST_GHOST_PAD_PRIVATE(obj) (GST_GHOST_PAD_CAST (obj)->priv) struct _GstGhostPadPrivate { /* with PROXY_LOCK */ gboolean constructed; }; G_DEFINE_TYPE (GstGhostPad, gst_ghost_pad, GST_TYPE_PROXY_PAD); static void gst_ghost_pad_dispose (GObject * object); static gboolean gst_ghost_pad_internal_activate_push_default (GstPad * pad, GstObject * parent, gboolean active) { gboolean ret; GstPad *other; GST_LOG_OBJECT (pad, "%sactivate push on %s:%s, we're ok", (active ? "" : "de"), GST_DEBUG_PAD_NAME (pad)); /* in both cases (SRC and SINK) we activate just the internal pad. The targets * will be activated later (or already in case of a ghost sinkpad). */ GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, other, FALSE); ret = gst_pad_activate_mode (other, GST_PAD_MODE_PUSH, active); GST_PROXY_PAD_RELEASE_INTERNAL (other); return ret; } static gboolean gst_ghost_pad_internal_activate_pull_default (GstPad * pad, GstObject * parent, gboolean active) { gboolean ret; GstPad *other; GST_LOG_OBJECT (pad, "%sactivate pull on %s:%s", (active ? "" : "de"), GST_DEBUG_PAD_NAME (pad)); if (GST_PAD_DIRECTION (pad) == GST_PAD_SRC) { /* we are activated in pull mode by our peer element, which is a sinkpad * that wants to operate in pull mode. This activation has to propagate * upstream through the pipeline. We call the internal activation function, * which will trigger gst_ghost_pad_activate_pull_default, which propagates even * further upstream */ GST_LOG_OBJECT (pad, "pad is src, activate internal"); GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, other, FALSE); ret = gst_pad_activate_mode (other, GST_PAD_MODE_PULL, active); GST_PROXY_PAD_RELEASE_INTERNAL (other); } else if (G_LIKELY ((other = gst_pad_get_peer (pad)))) { /* We are SINK, the ghostpad is SRC, we propagate the activation upstream * since we hold a pointer to the upstream peer. */ GST_LOG_OBJECT (pad, "activating peer"); ret = gst_pad_activate_mode (other, GST_PAD_MODE_PULL, active); gst_object_unref (other); } else { /* this is failure, we can't activate pull if there is no peer */ GST_LOG_OBJECT (pad, "not src and no peer, failing"); ret = FALSE; } return ret; } /** * gst_ghost_pad_internal_activate_mode_default: * @pad: the #GstPad to activate or deactivate. * @parent: (allow-none): the parent of @pad or NULL * @mode: the requested activation mode * @active: whether the pad should be active or not. * * Invoke the default activate mode function of a proxy pad that is * owned by a ghost pad. * * Returns: %TRUE if the operation was successful. */ gboolean gst_ghost_pad_internal_activate_mode_default (GstPad * pad, GstObject * parent, GstPadMode mode, gboolean active) { gboolean res; g_return_val_if_fail (GST_IS_PROXY_PAD (pad), FALSE); switch (mode) { case GST_PAD_MODE_PULL: res = gst_ghost_pad_internal_activate_pull_default (pad, parent, active); break; case GST_PAD_MODE_PUSH: res = gst_ghost_pad_internal_activate_push_default (pad, parent, active); break; default: GST_LOG_OBJECT (pad, "unknown activation mode %d", mode); res = FALSE; break; } return res; } static gboolean gst_ghost_pad_activate_push_default (GstPad * pad, GstObject * parent, gboolean active) { gboolean ret; GstPad *other; g_return_val_if_fail (GST_IS_GHOST_PAD (pad), FALSE); GST_LOG_OBJECT (pad, "%sactivate push on %s:%s, proxy internal", (active ? "" : "de"), GST_DEBUG_PAD_NAME (pad)); /* just activate the internal pad */ GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, other, FALSE); ret = gst_pad_activate_mode (other, GST_PAD_MODE_PUSH, active); GST_PROXY_PAD_RELEASE_INTERNAL (other); return ret; } static gboolean gst_ghost_pad_activate_pull_default (GstPad * pad, GstObject * parent, gboolean active) { gboolean ret; GstPad *other; GST_LOG_OBJECT (pad, "%sactivate pull on %s:%s", (active ? "" : "de"), GST_DEBUG_PAD_NAME (pad)); if (GST_PAD_DIRECTION (pad) == GST_PAD_SRC) { /* the ghostpad is SRC and activated in pull mode by its peer, call the * activation function of the internal pad to propagate the activation * upstream */ GST_LOG_OBJECT (pad, "pad is src, activate internal"); GST_PROXY_PAD_ACQUIRE_INTERNAL (pad, other, FALSE); ret = gst_pad_activate_mode (other, GST_PAD_MODE_PULL, active); GST_PROXY_PAD_RELEASE_INTERNAL (other); } else if (G_LIKELY ((other = gst_pad_get_peer (pad)))) { /* We are SINK and activated by the internal pad, propagate activation * upstream because we hold a ref to the upstream peer */ GST_LOG_OBJECT (pad, "activating peer"); ret = gst_pad_activate_mode (other, GST_PAD_MODE_PULL, active); gst_object_unref (other); } else { /* no peer, we fail */ GST_LOG_OBJECT (pad, "pad not src and no peer, failing"); ret = FALSE; } return ret; } /** * gst_ghost_pad_activate_mode_default: * @pad: the #GstPad to activate or deactivate. * @parent: (allow-none): the parent of @pad or NULL * @mode: the requested activation mode * @active: whether the pad should be active or not. * * Invoke the default activate mode function of a ghost pad. * * Returns: %TRUE if the operation was successful. */ gboolean gst_ghost_pad_activate_mode_default (GstPad * pad, GstObject * parent, GstPadMode mode, gboolean active) { gboolean res; g_return_val_if_fail (GST_IS_GHOST_PAD (pad), FALSE); switch (mode) { case GST_PAD_MODE_PULL: res = gst_ghost_pad_activate_pull_default (pad, parent, active); break; case GST_PAD_MODE_PUSH: res = gst_ghost_pad_activate_push_default (pad, parent, active); break; default: GST_LOG_OBJECT (pad, "unknown activation mode %d", mode); res = FALSE; break; } return res; } static void gst_ghost_pad_class_init (GstGhostPadClass * klass) { GObjectClass *gobject_class = (GObjectClass *) klass; g_type_class_add_private (klass, sizeof (GstGhostPadPrivate)); gobject_class->dispose = gst_ghost_pad_dispose; GST_DEBUG_REGISTER_FUNCPTR (gst_ghost_pad_activate_pull_default); GST_DEBUG_REGISTER_FUNCPTR (gst_ghost_pad_activate_push_default); } static void gst_ghost_pad_init (GstGhostPad * pad) { GST_GHOST_PAD_PRIVATE (pad) = G_TYPE_INSTANCE_GET_PRIVATE (pad, GST_TYPE_GHOST_PAD, GstGhostPadPrivate); gst_pad_set_activatemode_function (GST_PAD_CAST (pad), gst_ghost_pad_activate_mode_default); } static void gst_ghost_pad_dispose (GObject * object) { GstPad *pad; GstPad *internal; GstPad *peer; pad = GST_PAD (object); GST_DEBUG_OBJECT (pad, "dispose"); gst_ghost_pad_set_target (GST_GHOST_PAD (pad), NULL); /* Unlink here so that gst_pad_dispose doesn't. That would lead to a call to * gst_ghost_pad_unlink_default when the ghost pad is in an inconsistent state */ peer = gst_pad_get_peer (pad); if (peer) { if (GST_PAD_IS_SRC (pad)) gst_pad_unlink (pad, peer); else gst_pad_unlink (peer, pad); gst_object_unref (peer); } GST_OBJECT_LOCK (pad); internal = GST_PROXY_PAD_INTERNAL (pad); gst_pad_set_activatemode_function (internal, NULL); /* disposes of the internal pad, since the ghostpad is the only possible object * that has a refcount on the internal pad. */ gst_object_unparent (GST_OBJECT_CAST (internal)); GST_PROXY_PAD_INTERNAL (pad) = NULL; GST_OBJECT_UNLOCK (pad); G_OBJECT_CLASS (gst_ghost_pad_parent_class)->dispose (object); } /** * gst_ghost_pad_construct: * @gpad: the newly allocated ghost pad * * Finish initialization of a newly allocated ghost pad. * * This function is most useful in language bindings and when subclassing * #GstGhostPad; plugin and application developers normally will not call this * function. Call this function directly after a call to g_object_new * (GST_TYPE_GHOST_PAD, "direction", @dir, ..., NULL). * * Returns: %TRUE if the construction succeeds, %FALSE otherwise. */ gboolean gst_ghost_pad_construct (GstGhostPad * gpad) { GstPadDirection dir, otherdir; GstPadTemplate *templ; GstPad *pad, *internal; g_return_val_if_fail (GST_IS_GHOST_PAD (gpad), FALSE); g_return_val_if_fail (GST_GHOST_PAD_PRIVATE (gpad)->constructed == FALSE, FALSE); g_object_get (gpad, "direction", &dir, "template", &templ, NULL); g_return_val_if_fail (dir != GST_PAD_UNKNOWN, FALSE); pad = GST_PAD (gpad); /* Set directional padfunctions for ghostpad */ if (dir == GST_PAD_SINK) { gst_pad_set_chain_function (pad, gst_proxy_pad_chain_default); gst_pad_set_chain_list_function (pad, gst_proxy_pad_chain_list_default); } else { gst_pad_set_getrange_function (pad, gst_proxy_pad_getrange_default); } /* INTERNAL PAD, it always exists and is child of the ghostpad */ otherdir = (dir == GST_PAD_SRC) ? GST_PAD_SINK : GST_PAD_SRC; if (templ) { internal = g_object_new (GST_TYPE_PROXY_PAD, "name", NULL, "direction", otherdir, "template", templ, NULL); /* release ref obtained via g_object_get */ gst_object_unref (templ); } else { internal = g_object_new (GST_TYPE_PROXY_PAD, "name", NULL, "direction", otherdir, NULL); } GST_PAD_UNSET_FLUSHING (internal); /* Set directional padfunctions for internal pad */ if (dir == GST_PAD_SRC) { gst_pad_set_chain_function (internal, gst_proxy_pad_chain_default); gst_pad_set_chain_list_function (internal, gst_proxy_pad_chain_list_default); } else { gst_pad_set_getrange_function (internal, gst_proxy_pad_getrange_default); } GST_OBJECT_LOCK (pad); /* now make the ghostpad a parent of the internal pad */ if (!gst_object_set_parent (GST_OBJECT_CAST (internal), GST_OBJECT_CAST (pad))) goto parent_failed; /* The ghostpad is the parent of the internal pad and is the only object that * can have a refcount on the internal pad. * At this point, the GstGhostPad has a refcount of 1, and the internal pad has * a refcount of 1. * When the refcount of the GstGhostPad drops to 0, the ghostpad will dispose * its refcount on the internal pad in the dispose method by un-parenting it. * This is why we don't take extra refcounts in the assignments below */ GST_PROXY_PAD_INTERNAL (pad) = internal; GST_PROXY_PAD_INTERNAL (internal) = pad; /* special activation functions for the internal pad */ gst_pad_set_activatemode_function (internal, gst_ghost_pad_internal_activate_mode_default); GST_OBJECT_UNLOCK (pad); GST_GHOST_PAD_PRIVATE (gpad)->constructed = TRUE; return TRUE; /* ERRORS */ parent_failed: { GST_WARNING_OBJECT (gpad, "Could not set internal pad %s:%s", GST_DEBUG_PAD_NAME (internal)); g_critical ("Could not set internal pad %s:%s", GST_DEBUG_PAD_NAME (internal)); GST_OBJECT_UNLOCK (pad); gst_object_unref (internal); return FALSE; } } static GstPad * gst_ghost_pad_new_full (const gchar * name, GstPadDirection dir, GstPadTemplate * templ) { GstGhostPad *ret; g_return_val_if_fail (dir != GST_PAD_UNKNOWN, NULL); /* OBJECT CREATION */ if (templ) { ret = g_object_new (GST_TYPE_GHOST_PAD, "name", name, "direction", dir, "template", templ, NULL); } else { ret = g_object_new (GST_TYPE_GHOST_PAD, "name", name, "direction", dir, NULL); } if (!gst_ghost_pad_construct (ret)) goto construct_failed; return GST_PAD_CAST (ret); construct_failed: /* already logged */ gst_object_unref (ret); return NULL; } /** * gst_ghost_pad_new_no_target: * @name: (allow-none): the name of the new pad, or NULL to assign a default name. * @dir: the direction of the ghostpad * * Create a new ghostpad without a target with the given direction. * A target can be set on the ghostpad later with the * gst_ghost_pad_set_target() function. * * The created ghostpad will not have a padtemplate. * * Returns: (transfer full): a new #GstPad, or NULL in case of an error. */ GstPad * gst_ghost_pad_new_no_target (const gchar * name, GstPadDirection dir) { GstPad *ret; g_return_val_if_fail (dir != GST_PAD_UNKNOWN, NULL); GST_LOG ("name:%s, direction:%d", GST_STR_NULL (name), dir); ret = gst_ghost_pad_new_full (name, dir, NULL); return ret; } /** * gst_ghost_pad_new: * @name: (allow-none): the name of the new pad, or NULL to assign a default name * @target: (transfer none): the pad to ghost. * * Create a new ghostpad with @target as the target. The direction will be taken * from the target pad. @target must be unlinked. * * Will ref the target. * * Returns: (transfer floating): a new #GstPad, or NULL in case of an error. */ GstPad * gst_ghost_pad_new (const gchar * name, GstPad * target) { GstPad *ret; g_return_val_if_fail (GST_IS_PAD (target), NULL); g_return_val_if_fail (!gst_pad_is_linked (target), NULL); GST_LOG ("name:%s, target:%s:%s", GST_STR_NULL (name), GST_DEBUG_PAD_NAME (target)); if ((ret = gst_ghost_pad_new_no_target (name, GST_PAD_DIRECTION (target)))) if (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (ret), target)) goto set_target_failed; return ret; /* ERRORS */ set_target_failed: { GST_WARNING_OBJECT (ret, "failed to set target %s:%s", GST_DEBUG_PAD_NAME (target)); gst_object_unref (ret); return NULL; } } /** * gst_ghost_pad_new_from_template: * @name: (allow-none): the name of the new pad, or NULL to assign a default name. * @target: (transfer none): the pad to ghost. * @templ: (transfer none): the #GstPadTemplate to use on the ghostpad. * * Create a new ghostpad with @target as the target. The direction will be taken * from the target pad. The template used on the ghostpad will be @template. * * Will ref the target. * * Returns: (transfer full): a new #GstPad, or NULL in case of an error. */ GstPad * gst_ghost_pad_new_from_template (const gchar * name, GstPad * target, GstPadTemplate * templ) { GstPad *ret; g_return_val_if_fail (GST_IS_PAD (target), NULL); g_return_val_if_fail (!gst_pad_is_linked (target), NULL); g_return_val_if_fail (templ != NULL, NULL); g_return_val_if_fail (GST_PAD_TEMPLATE_DIRECTION (templ) == GST_PAD_DIRECTION (target), NULL); GST_LOG ("name:%s, target:%s:%s, templ:%p", GST_STR_NULL (name), GST_DEBUG_PAD_NAME (target), templ); if ((ret = gst_ghost_pad_new_full (name, GST_PAD_DIRECTION (target), templ))) if (!gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (ret), target)) goto set_target_failed; return ret; /* ERRORS */ set_target_failed: { GST_WARNING_OBJECT (ret, "failed to set target %s:%s", GST_DEBUG_PAD_NAME (target)); gst_object_unref (ret); return NULL; } } /** * gst_ghost_pad_new_no_target_from_template: * @name: (allow-none): the name of the new pad, or NULL to assign a default name * @templ: (transfer none): the #GstPadTemplate to create the ghostpad from. * * Create a new ghostpad based on @templ, without setting a target. The * direction will be taken from the @templ. * * Returns: (transfer full): a new #GstPad, or NULL in case of an error. */ GstPad * gst_ghost_pad_new_no_target_from_template (const gchar * name, GstPadTemplate * templ) { GstPad *ret; g_return_val_if_fail (templ != NULL, NULL); ret = gst_ghost_pad_new_full (name, GST_PAD_TEMPLATE_DIRECTION (templ), templ); return ret; } /** * gst_ghost_pad_get_target: * @gpad: the #GstGhostPad * * Get the target pad of @gpad. Unref target pad after usage. * * Returns: (transfer full): the target #GstPad, can be NULL if the ghostpad * has no target set. Unref target pad after usage. */ GstPad * gst_ghost_pad_get_target (GstGhostPad * gpad) { GstPad *ret; g_return_val_if_fail (GST_IS_GHOST_PAD (gpad), NULL); ret = gst_proxy_pad_get_target (GST_PAD_CAST (gpad)); GST_DEBUG_OBJECT (gpad, "get target %s:%s", GST_DEBUG_PAD_NAME (ret)); return ret; } static gboolean clear_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GST_DEBUG_OBJECT (pad, "clearing sticky event %" GST_PTR_FORMAT, *event); gst_event_unref (*event); *event = NULL; return TRUE; } static gboolean copy_sticky_events (GstPad * pad, GstEvent ** event, gpointer user_data) { GstPad *internal = GST_PAD_CAST (user_data); GST_DEBUG_OBJECT (internal, "store sticky event %" GST_PTR_FORMAT, *event); gst_pad_store_sticky_event (internal, *event); return TRUE; } /** * gst_ghost_pad_set_target: * @gpad: the #GstGhostPad * @newtarget: (transfer none) (allow-none): the new pad target * * Set the new target of the ghostpad @gpad. Any existing target * is unlinked and links to the new target are established. if @newtarget is * NULL the target will be cleared. * * Returns: (transfer full): TRUE if the new target could be set. This function * can return FALSE when the internal pads could not be linked. */ gboolean gst_ghost_pad_set_target (GstGhostPad * gpad, GstPad * newtarget) { GstPad *internal; GstPad *oldtarget; GstPadLinkReturn lret; g_return_val_if_fail (GST_IS_GHOST_PAD (gpad), FALSE); g_return_val_if_fail (GST_PAD_CAST (gpad) != newtarget, FALSE); g_return_val_if_fail (newtarget != GST_PROXY_PAD_INTERNAL (gpad), FALSE); GST_OBJECT_LOCK (gpad); internal = GST_PROXY_PAD_INTERNAL (gpad); if (newtarget) GST_DEBUG_OBJECT (gpad, "set target %s:%s", GST_DEBUG_PAD_NAME (newtarget)); else GST_DEBUG_OBJECT (gpad, "clearing target"); /* clear old target */ if ((oldtarget = GST_PROXY_PAD_TARGET (gpad))) { GST_OBJECT_UNLOCK (gpad); /* unlink internal pad */ if (GST_PAD_IS_SRC (internal)) gst_pad_unlink (internal, oldtarget); else gst_pad_unlink (oldtarget, internal); if (GST_PAD_IS_SRC (gpad)) { /* only clear the events on the SRC ghostpad. We don't clear sink * ghostpads, they got their events from downstream and we want to * set the same events on the target later. */ gst_pad_sticky_events_foreach (GST_PAD_CAST (gpad), clear_sticky_events, NULL); } } else { GST_OBJECT_UNLOCK (gpad); } if (newtarget) { /* and link to internal pad without any checks */ GST_DEBUG_OBJECT (gpad, "connecting internal pad to target %" GST_PTR_FORMAT, newtarget); if (GST_PAD_IS_SRC (internal)) lret = gst_pad_link_full (internal, newtarget, GST_PAD_LINK_CHECK_NOTHING); else lret = gst_pad_link_full (newtarget, internal, GST_PAD_LINK_CHECK_NOTHING); if (lret != GST_PAD_LINK_OK) goto link_failed; if (GST_PAD_IS_SRC (gpad)) { /* only copy the events to the SRC ghostpad. We don't copy to sink * ghostpads, they got their events from downstream and we don't want * to overwrite those with events from this new target. */ gst_pad_sticky_events_foreach (newtarget, copy_sticky_events, gpad); } } return TRUE; /* ERRORS */ link_failed: { GST_WARNING_OBJECT (gpad, "could not link internal and target, reason:%d", lret); return FALSE; } }