/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2004 Wim Taymans <wim@fluendo.com>

 *

 * gstelement.c: The base element, all elements derive from this

 *

 * 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:gstelement

 * @title: GstElement

 * @short_description: Abstract base class for all pipeline elements

 * @see_also: #GstElementFactory, #GstPad

 *

 * GstElement is the abstract base class needed to construct an element that

 * can be used in a GStreamer pipeline. Please refer to the plugin writers

 * guide for more information on creating #GstElement subclasses.

 *

 * The name of a #GstElement can be get with gst_element_get_name() and set with

 * gst_element_set_name().  For speed, GST_ELEMENT_NAME() can be used in the

 * core when using the appropriate locking. Do not use this in plug-ins or

 * applications in order to retain ABI compatibility.

 *

 * Elements can have pads (of the type #GstPad).  These pads link to pads on

 * other elements.  #GstBuffer flow between these linked pads.

 * A #GstElement has a #GList of #GstPad structures for all their input (or sink)

 * and output (or source) pads.

 * Core and plug-in writers can add and remove pads with gst_element_add_pad()

 * and gst_element_remove_pad().

 *

 * An existing pad of an element can be retrieved by name with

 * gst_element_get_static_pad(). A new dynamic pad can be created using

 * gst_element_request_pad() with a #GstPadTemplate.

 * An iterator of all pads can be retrieved with gst_element_iterate_pads().

 *

 * Elements can be linked through their pads.

 * If the link is straightforward, use the gst_element_link()

 * convenience function to link two elements, or gst_element_link_many()

 * for more elements in a row.

 * Use gst_element_link_filtered() to link two elements constrained by

 * a specified set of #GstCaps.

 * For finer control, use gst_element_link_pads() and

 * gst_element_link_pads_filtered() to specify the pads to link on

 * each element by name.

 *

 * Each element has a state (see #GstState).  You can get and set the state

 * of an element with gst_element_get_state() and gst_element_set_state().

 * Setting a state triggers a #GstStateChange. To get a string representation

 * of a #GstState, use gst_element_state_get_name().

 *

 * You can get and set a #GstClock on an element using gst_element_get_clock()

 * and gst_element_set_clock().

 * Some elements can provide a clock for the pipeline if

 * the #GST_ELEMENT_FLAG_PROVIDE_CLOCK flag is set. With the

 * gst_element_provide_clock() method one can retrieve the clock provided by

 * such an element.

 * Not all elements require a clock to operate correctly. If the

 * #GST_ELEMENT_FLAG_REQUIRE_CLOCK() flag is set, a clock should be set on the

 * element with gst_element_set_clock().

 *

 * Note that clock selection and distribution is normally handled by the

 * toplevel #GstPipeline so the clock functions are only to be used in very

 * specific situations.

 */

#include "gst_private.h"

#include <glib.h>

#include <stdarg.h>

#include <gobject/gvaluecollector.h>

#include "gstelement.h"

#include "gstelementmetadata.h"

#include "gstenumtypes.h"

#include "gstbus.h"

#include "gsterror.h"

#include "gstevent.h"

#include "gstutils.h"

#include "gstinfo.h"

#include "gstquark.h"

#include "gsttracerutils.h"

#include "gstvalue.h"

#include "gst-i18n-lib.h"

#include "glib-compat-private.h"

#ifndef GST_DISABLE_GST_DEBUG

#include "printf/printf.h"

#endif

/* Element signals and args */

enum

{

  PAD_ADDED,

  PAD_REMOVED,

  NO_MORE_PADS,

  /* add more above */

  LAST_SIGNAL

};

enum

{

  ARG_0

      /* FILL ME */

};

static void gst_element_class_init (GstElementClass * klass);

static void gst_element_init (GstElement * element);

static void gst_element_base_class_init (gpointer g_class);

static void gst_element_constructed (GObject * object);

static void gst_element_dispose (GObject * object);

static void gst_element_finalize (GObject * object);

static GstStateChangeReturn gst_element_change_state_func (GstElement * element,

    GstStateChange transition);

static GstStateChangeReturn gst_element_get_state_func (GstElement * element,

    GstState * state, GstState * pending, GstClockTime timeout);

static GstStateChangeReturn gst_element_set_state_func (GstElement * element,

    GstState state);

static gboolean gst_element_set_clock_func (GstElement * element,

    GstClock * clock);

static void gst_element_set_bus_func (GstElement * element, GstBus * bus);

static gboolean gst_element_post_message_default (GstElement * element,

    GstMessage * message);

static void gst_element_set_context_default (GstElement * element,

    GstContext * context);

static gboolean gst_element_default_send_event (GstElement * element,

    GstEvent * event);

static gboolean gst_element_default_query (GstElement * element,

    GstQuery * query);

static GstPadTemplate

    * gst_element_class_get_request_pad_template (GstElementClass *

    element_class, const gchar * name);

static void gst_element_call_async_func (gpointer data, gpointer user_data);

static GstObjectClass *parent_class = NULL;

static guint gst_element_signals[LAST_SIGNAL] = { 0 };

static GThreadPool *gst_element_pool = NULL;

/* this is used in gstelementfactory.c:gst_element_register() */

GQuark __gst_elementclass_factory = 0;

GType

gst_element_get_type (void)

{

  static volatile gsize gst_element_type = 0;

  if (g_once_init_enter (&gst_element_type)) {

    GType _type;

    static const GTypeInfo element_info = {

      sizeof (GstElementClass),

      gst_element_base_class_init,

      NULL,                     /* base_class_finalize */

      (GClassInitFunc) gst_element_class_init,

      NULL,

      NULL,

      sizeof (GstElement),

      0,

      (GInstanceInitFunc) gst_element_init,

      NULL

    };

    _type = g_type_register_static (GST_TYPE_OBJECT, "GstElement",

        &element_info, G_TYPE_FLAG_ABSTRACT);

    __gst_elementclass_factory =

        g_quark_from_static_string ("GST_ELEMENTCLASS_FACTORY");

    g_once_init_leave (&gst_element_type, _type);

  }

  return gst_element_type;

}

static void

gst_element_setup_thread_pool (void)

{

  GError *err = NULL;

  GST_DEBUG ("creating element thread pool");

  gst_element_pool =

      g_thread_pool_new ((GFunc) gst_element_call_async_func, NULL, -1, FALSE,

      &err;;

  if (err != NULL) {

    g_critical ("could not alloc threadpool %s", err->message);

    g_clear_error (&err;;

  }

}

static void

gst_element_class_init (GstElementClass * klass)

{

  GObjectClass *gobject_class;

  gobject_class = (GObjectClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  /**

   * GstElement::pad-added:

   * @gstelement: the object which received the signal

   * @new_pad: the pad that has been added

   *

   * a new #GstPad has been added to the element. Note that this signal will

   * usually be emitted from the context of the streaming thread. Also keep in

   * mind that if you add new elements to the pipeline in the signal handler

   * you will need to set them to the desired target state with

   * gst_element_set_state() or gst_element_sync_state_with_parent().

   */

  gst_element_signals[PAD_ADDED] =

      g_signal_new ("pad-added", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstElementClass, pad_added), NULL, NULL,

      g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_PAD);

  /**

   * GstElement::pad-removed:

   * @gstelement: the object which received the signal

   * @old_pad: the pad that has been removed

   *

   * a #GstPad has been removed from the element

   */

  gst_element_signals[PAD_REMOVED] =

      g_signal_new ("pad-removed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      G_STRUCT_OFFSET (GstElementClass, pad_removed), NULL, NULL,

      g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_PAD);

  /**

   * GstElement::no-more-pads:

   * @gstelement: the object which received the signal

   *

   * This signals that the element will not generate more dynamic pads.

   * Note that this signal will usually be emitted from the context of

   * the streaming thread.

   */

  gst_element_signals[NO_MORE_PADS] =

      g_signal_new ("no-more-pads", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstElementClass, no_more_pads), NULL,

      NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 0);

  gobject_class->dispose = gst_element_dispose;

  gobject_class->finalize = gst_element_finalize;

  gobject_class->constructed = gst_element_constructed;

  klass->change_state = GST_DEBUG_FUNCPTR (gst_element_change_state_func);

  klass->set_state = GST_DEBUG_FUNCPTR (gst_element_set_state_func);

  klass->get_state = GST_DEBUG_FUNCPTR (gst_element_get_state_func);

  klass->set_clock = GST_DEBUG_FUNCPTR (gst_element_set_clock_func);

  klass->set_bus = GST_DEBUG_FUNCPTR (gst_element_set_bus_func);

  klass->query = GST_DEBUG_FUNCPTR (gst_element_default_query);

  klass->send_event = GST_DEBUG_FUNCPTR (gst_element_default_send_event);

  klass->numpadtemplates = 0;

  klass->post_message = GST_DEBUG_FUNCPTR (gst_element_post_message_default);

  klass->set_context = GST_DEBUG_FUNCPTR (gst_element_set_context_default);

  klass->elementfactory = NULL;

  gst_element_setup_thread_pool ();

}

static void

gst_element_base_class_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  GList *node, *padtemplates;

  /* Copy the element details here so elements can inherit the

   * details from their base class and classes only need to set

   * the details in class_init instead of base_init */

  element_class->metadata =

      element_class->metadata ? gst_structure_copy (element_class->metadata) :

      gst_structure_new_empty ("metadata");

  /* Copy the pad templates so elements inherit them

   * from their base class but elements can add pad templates in class_init

   * instead of base_init.

   */

  padtemplates = g_list_copy (element_class->padtemplates);

  for (node = padtemplates; node != NULL; node = node->next) {

    GstPadTemplate *tmpl = (GstPadTemplate *) node->data;

    gst_object_ref (tmpl);

  }

  element_class->padtemplates = padtemplates;

  /* set the factory, see gst_element_register() */

  element_class->elementfactory =

      g_type_get_qdata (G_TYPE_FROM_CLASS (element_class),

      __gst_elementclass_factory);

  GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "type %s : factory %p",

      G_OBJECT_CLASS_NAME (element_class), element_class->elementfactory);

}

static void

gst_element_init (GstElement * element)

{

  GST_STATE (element) = GST_STATE_NULL;

  GST_STATE_TARGET (element) = GST_STATE_NULL;

  GST_STATE_NEXT (element) = GST_STATE_VOID_PENDING;

  GST_STATE_PENDING (element) = GST_STATE_VOID_PENDING;

  GST_STATE_RETURN (element) = GST_STATE_CHANGE_SUCCESS;

  g_rec_mutex_init (&element->state_lock);

  g_cond_init (&element->state_cond);

}

static void

gst_element_constructed (GObject * object)

{

  GST_TRACER_ELEMENT_NEW (GST_ELEMENT_CAST (object));

  G_OBJECT_CLASS (parent_class)->constructed (object);

}

/**

 * gst_element_release_request_pad:

 * @element: a #GstElement to release the request pad of.

 * @pad: the #GstPad to release.

 *

 * Makes the element free the previously requested pad as obtained

 * with gst_element_request_pad().

 *

 * This does not unref the pad. If the pad was created by using

 * gst_element_request_pad(), gst_element_release_request_pad() needs to be

 * followed by gst_object_unref() to free the @pad.

 *

 * MT safe.

 */

void

gst_element_release_request_pad (GstElement * element, GstPad * pad)

{

  GstElementClass *oclass;

  g_return_if_fail (GST_IS_ELEMENT (element));

  g_return_if_fail (GST_IS_PAD (pad));

  g_return_if_fail (GST_PAD_PAD_TEMPLATE (pad) == NULL ||

      GST_PAD_TEMPLATE_PRESENCE (GST_PAD_PAD_TEMPLATE (pad)) ==

      GST_PAD_REQUEST);

  g_return_if_fail (GST_PAD_PARENT (pad) == element);

  oclass = GST_ELEMENT_GET_CLASS (element);

  /* if the element implements a custom release function we call that, else we

   * simply remove the pad from the element */

  if (oclass->release_pad)

    oclass->release_pad (element, pad);

  else

    gst_element_remove_pad (element, pad);

}

/**

 * gst_element_provide_clock:

 * @element: a #GstElement to query

 *

 * Get the clock provided by the given element.

 * > An element is only required to provide a clock in the PAUSED

 * > state. Some elements can provide a clock in other states.

 *

 * Returns: (transfer full) (nullable): the GstClock provided by the

 * element or %NULL if no clock could be provided.  Unref after usage.

 *

 * MT safe.

 */

GstClock *

gst_element_provide_clock (GstElement * element)

{

  GstClock *result = NULL;

  GstElementClass *oclass;

  g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);

  oclass = GST_ELEMENT_GET_CLASS (element);

  if (oclass->provide_clock)

    result = oclass->provide_clock (element);

  return result;

}

static gboolean

gst_element_set_clock_func (GstElement * element, GstClock * clock)

{

  GstClock **clock_p;

  GST_OBJECT_LOCK (element);

  clock_p = &element->clock;

  gst_object_replace ((GstObject **) clock_p, (GstObject *) clock);

  GST_OBJECT_UNLOCK (element);

  return TRUE;

}

/**

 * gst_element_set_clock:

 * @element: a #GstElement to set the clock for.

 * @clock: (transfer none) (allow-none): the #GstClock to set for the element.

 *

 * Sets the clock for the element. This function increases the

 * refcount on the clock. Any previously set clock on the object

 * is unreffed.

 *

 * Returns: %TRUE if the element accepted the clock. An element can refuse a

 * clock when it, for example, is not able to slave its internal clock to the

 * @clock or when it requires a specific clock to operate.

 *

 * MT safe.

 */

gboolean

gst_element_set_clock (GstElement * element, GstClock * clock)

{

  GstElementClass *oclass;

  gboolean res = FALSE;

  g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);

  g_return_val_if_fail (clock == NULL || GST_IS_CLOCK (clock), FALSE);

  oclass = GST_ELEMENT_GET_CLASS (element);

  GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, element, "setting clock %p", clock);

  if (oclass->set_clock)

    res = oclass->set_clock (element, clock);

  return res;

}

/**

 * gst_element_get_clock:

 * @element: a #GstElement to get the clock of.

 *

 * Gets the currently configured clock of the element. This is the clock as was

 * last set with gst_element_set_clock().

 *

 * Elements in a pipeline will only have their clock set when the

 * pipeline is in the PLAYING state.

 *

 * Returns: (transfer full) (nullable): the #GstClock of the element. unref after usage.

 *

 * MT safe.

 */

GstClock *

gst_element_get_clock (GstElement * element)

{

  GstClock *result;

  g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);

  GST_OBJECT_LOCK (element);

  if ((result = element->clock))

    gst_object_ref (result);

  GST_OBJECT_UNLOCK (element);

  return result;

}

/**

 * gst_element_set_base_time:

 * @element: a #GstElement.

 * @time: the base time to set.

 *

 * Set the base time of an element. See gst_element_get_base_time().

 *

 * MT safe.

 */

void

gst_element_set_base_time (GstElement * element, GstClockTime time)

{

  GstClockTime old;

  g_return_if_fail (GST_IS_ELEMENT (element));

  GST_OBJECT_LOCK (element);

  old = element->base_time;

  element->base_time = time;

  GST_OBJECT_UNLOCK (element);

  GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, element,

      "set base_time=%" GST_TIME_FORMAT ", old %" GST_TIME_FORMAT,

      GST_TIME_ARGS (time), GST_TIME_ARGS (old));

}

/**

 * gst_element_get_base_time:

 * @element: a #GstElement.

 *

 * Returns the base time of the element. The base time is the

 * absolute time of the clock when this element was last put to

 * PLAYING. Subtracting the base time from the clock time gives

 * the running time of the element.

 *

 * Returns: the base time of the element.

 *

 * MT safe.

 */

GstClockTime

gst_element_get_base_time (GstElement * element)

{

  GstClockTime result;

  g_return_val_if_fail (GST_IS_ELEMENT (element), GST_CLOCK_TIME_NONE);

  GST_OBJECT_LOCK (element);

  result = element->base_time;

  GST_OBJECT_UNLOCK (element);

  return result;

}

/**

 * gst_element_set_start_time:

 * @element: a #GstElement.

 * @time: the base time to set.

 *

 * Set the start time of an element. The start time of the element is the

 * running time of the element when it last went to the PAUSED state. In READY

 * or after a flushing seek, it is set to 0.

 *

 * Toplevel elements like #GstPipeline will manage the start_time and

 * base_time on its children. Setting the start_time to #GST_CLOCK_TIME_NONE

 * on such a toplevel element will disable the distribution of the base_time to

 * the children and can be useful if the application manages the base_time

 * itself, for example if you want to synchronize capture from multiple

 * pipelines, and you can also ensure that the pipelines have the same clock.

 *

 * MT safe.

 */

void

gst_element_set_start_time (GstElement * element, GstClockTime time)

{

  GstClockTime old;

  g_return_if_fail (GST_IS_ELEMENT (element));

  GST_OBJECT_LOCK (element);

  old = GST_ELEMENT_START_TIME (element);

  GST_ELEMENT_START_TIME (element) = time;

  GST_OBJECT_UNLOCK (element);

  GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, element,

      "set start_time=%" GST_TIME_FORMAT ", old %" GST_TIME_FORMAT,

      GST_TIME_ARGS (time), GST_TIME_ARGS (old));

}

/**

 * gst_element_get_start_time:

 * @element: a #GstElement.

 *

 * Returns the start time of the element. The start time is the

 * running time of the clock when this element was last put to PAUSED.

 *

 * Usually the start_time is managed by a toplevel element such as

 * #GstPipeline.

 *

 * MT safe.

 *

 * Returns: the start time of the element.

 */

GstClockTime

gst_element_get_start_time (GstElement * element)

{

  GstClockTime result;

  g_return_val_if_fail (GST_IS_ELEMENT (element), GST_CLOCK_TIME_NONE);

  GST_OBJECT_LOCK (element);

  result = GST_ELEMENT_START_TIME (element);

  GST_OBJECT_UNLOCK (element);

  return result;

}

#if 0

/**

 * gst_element_set_index:

 * @element: a #GstElement.

 * @index: (transfer none): a #GstIndex.

 *

 * Set @index on the element. The refcount of the index

 * will be increased, any previously set index is unreffed.

 *

 * MT safe.

 */

void

gst_element_set_index (GstElement * element, GstIndex * index)

{

  GstElementClass *oclass;

  g_return_if_fail (GST_IS_ELEMENT (element));

  g_return_if_fail (index == NULL || GST_IS_INDEX (index));

  oclass = GST_ELEMENT_GET_CLASS (element);

  if (oclass->set_index)

    oclass->set_index (element, index);

}

/**

 * gst_element_get_index:

 * @element: a #GstElement.

 *

 * Gets the index from the element.

 *

 * Returns: (transfer full) (nullable): a #GstIndex or %NULL when no

 * index was set on the element. unref after usage.

 *

 * MT safe.

 */

GstIndex *

gst_element_get_index (GstElement * element)

{

  GstElementClass *oclass;

  GstIndex *result = NULL;

  g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);

  oclass = GST_ELEMENT_GET_CLASS (element);

  if (oclass->get_index)

    result = oclass->get_index (element);

  return result;

}

#endif

/**

 * gst_element_add_pad:

 * @element: a #GstElement to add the pad to.

 * @pad: (transfer floating): the #GstPad to add to the element.

 *

 * Adds a pad (link point) to @element. @pad's parent will be set to @element;

 * see gst_object_set_parent() for refcounting information.

 *

 * Pads are not automatically activated so elements should perform the needed

 * steps to activate the pad in case this pad is added in the PAUSED or PLAYING

 * state. See gst_pad_set_active() for more information about activating pads.

 *

 * The pad and the element should be unlocked when calling this function.

 *

 * This function will emit the #GstElement::pad-added signal on the element.

 *

 * Returns: %TRUE if the pad could be added. This function can fail when

 * a pad with the same name already existed or the pad already had another

 * parent.

 *

 * MT safe.

 */

gboolean

gst_element_add_pad (GstElement * element, GstPad * pad)

{

  gchar *pad_name;

  gboolean active;

  g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);

  g_return_val_if_fail (GST_IS_PAD (pad), FALSE);

  /* locking pad to look at the name */

  GST_OBJECT_LOCK (pad);

  pad_name = g_strdup (GST_PAD_NAME (pad));

  GST_CAT_INFO_OBJECT (GST_CAT_ELEMENT_PADS, element, "adding pad '%s'",

      GST_STR_NULL (pad_name));

  active = GST_PAD_IS_ACTIVE (pad);

  GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_PARENT);

  GST_OBJECT_UNLOCK (pad);

  /* then check to see if there's already a pad by that name here */

  GST_OBJECT_LOCK (element);

  if (G_UNLIKELY (!gst_object_check_uniqueness (element->pads, pad_name)))

    goto name_exists;

  /* try to set the pad's parent */

  if (G_UNLIKELY (!gst_object_set_parent (GST_OBJECT_CAST (pad),

              GST_OBJECT_CAST (element))))

    goto had_parent;

  /* check for active pads */

  if (!active && (GST_STATE (element) > GST_STATE_READY ||

          GST_STATE_NEXT (element) == GST_STATE_PAUSED)) {

    g_warning ("adding inactive pad '%s' to running element '%s', you need to "

        "use gst_pad_set_active(pad,TRUE) before adding it.",

        GST_STR_NULL (pad_name), GST_ELEMENT_NAME (element));

    gst_pad_set_active (pad, TRUE);

  }

  g_free (pad_name);

  /* add it to the list */

  switch (gst_pad_get_direction (pad)) {

    case GST_PAD_SRC:

      element->srcpads = g_list_append (element->srcpads, pad);

      element->numsrcpads++;

      break;

    case GST_PAD_SINK:

      element->sinkpads = g_list_append (element->sinkpads, pad);

      element->numsinkpads++;

      break;

    default:

      goto no_direction;

  }

  element->pads = g_list_append (element->pads, pad);

  element->numpads++;

  element->pads_cookie++;

  GST_OBJECT_UNLOCK (element);

  /* emit the PAD_ADDED signal */

  g_signal_emit (element, gst_element_signals[PAD_ADDED], 0, pad);

  GST_TRACER_ELEMENT_ADD_PAD (element, pad);

  return TRUE;

  /* ERROR cases */

name_exists:

  {

    g_critical ("Padname %s is not unique in element %s, not adding",

        pad_name, GST_ELEMENT_NAME (element));

    GST_OBJECT_UNLOCK (element);

    g_free (pad_name);

    gst_object_ref_sink (pad);

    gst_object_unref (pad);

    return FALSE;

  }

had_parent:

  {

    g_critical

        ("Pad %s already has parent when trying to add to element %s",

        pad_name, GST_ELEMENT_NAME (element));

    GST_OBJECT_UNLOCK (element);

    g_free (pad_name);

    return FALSE;

  }

no_direction:

  {

    GST_OBJECT_LOCK (pad);

    g_critical

        ("Trying to add pad %s to element %s, but it has no direction",

        GST_OBJECT_NAME (pad), GST_ELEMENT_NAME (element));

    GST_OBJECT_UNLOCK (pad);

    GST_OBJECT_UNLOCK (element);

    return FALSE;

  }

}

/**

 * gst_element_remove_pad:

 * @element: a #GstElement to remove pad from.

 * @pad: (transfer none): the #GstPad to remove from the element.

 *

 * Removes @pad from @element. @pad will be destroyed if it has not been

 * referenced elsewhere using gst_object_unparent().

 *

 * This function is used by plugin developers and should not be used

 * by applications. Pads that were dynamically requested from elements

 * with gst_element_request_pad() should be released with the

 * gst_element_release_request_pad() function instead.

 *

 * Pads are not automatically deactivated so elements should perform the needed

 * steps to deactivate the pad in case this pad is removed in the PAUSED or

 * PLAYING state. See gst_pad_set_active() for more information about

 * deactivating pads.

 *

 * The pad and the element should be unlocked when calling this function.

 *

 * This function will emit the #GstElement::pad-removed signal on the element.

 *

 * Returns: %TRUE if the pad could be removed. Can return %FALSE if the

 * pad does not belong to the provided element.

 *

 * MT safe.

 */

gboolean

gst_element_remove_pad (GstElement * element, GstPad * pad)

{

  GstPad *peer;

  g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);

  g_return_val_if_fail (GST_IS_PAD (pad), FALSE);

  /* locking pad to look at the name and parent */

  GST_OBJECT_LOCK (pad);

  GST_CAT_INFO_OBJECT (GST_CAT_ELEMENT_PADS, element, "removing pad '%s'",

      GST_STR_NULL (GST_PAD_NAME (pad)));

  if (G_UNLIKELY (GST_PAD_PARENT (pad) != element))

    goto not_our_pad;

  GST_OBJECT_UNLOCK (pad);

  /* unlink */

  if ((peer = gst_pad_get_peer (pad))) {

    /* window for MT unsafeness, someone else could unlink here

     * and then we call unlink with wrong pads. The unlink

     * function would catch this and safely return failed. */

    if (GST_PAD_IS_SRC (pad))

      gst_pad_unlink (pad, peer);

    else

      gst_pad_unlink (peer, pad);

    gst_object_unref (peer);

  }

  GST_OBJECT_LOCK (element);

  /* remove it from the list */

  switch (gst_pad_get_direction (pad)) {

    case GST_PAD_SRC:

      element->srcpads = g_list_remove (element->srcpads, pad);

      element->numsrcpads--;

      break;

    case GST_PAD_SINK:

      element->sinkpads = g_list_remove (element->sinkpads, pad);

      element->numsinkpads--;

      break;

    default:

      g_critical ("Removing pad without direction???");

      break;

  }

  element->pads = g_list_remove (element->pads, pad);

  element->numpads--;

  element->pads_cookie++;

  GST_OBJECT_UNLOCK (element);

  /* emit the PAD_REMOVED signal before unparenting and losing the last ref. */

  g_signal_emit (element, gst_element_signals[PAD_REMOVED], 0, pad);

  GST_TRACER_ELEMENT_REMOVE_PAD (element, pad);

  gst_object_unparent (GST_OBJECT_CAST (pad));

  return TRUE;

  /* ERRORS */

not_our_pad:

  {

    /* locking order is element > pad */

    GST_OBJECT_UNLOCK (pad);

    GST_OBJECT_LOCK (element);

    GST_OBJECT_LOCK (pad);

    g_critical ("Padname %s:%s does not belong to element %s when removing",

        GST_DEBUG_PAD_NAME (pad), GST_ELEMENT_NAME (element));

    GST_OBJECT_UNLOCK (pad);

    GST_OBJECT_UNLOCK (element);

    return FALSE;

  }

}

/**

 * gst_element_no_more_pads:

 * @element: a #GstElement

 *

 * Use this function to signal that the element does not expect any more pads

 * to show up in the current pipeline. This function should be called whenever

 * pads have been added by the element itself. Elements with #GST_PAD_SOMETIMES

 * pad templates use this in combination with autopluggers to figure out that

 * the element is done initializing its pads.

 *

 * This function emits the #GstElement::no-more-pads signal.

 *

 * MT safe.

 */

void

gst_element_no_more_pads (GstElement * element)

{

  g_return_if_fail (GST_IS_ELEMENT (element));

  g_signal_emit (element, gst_element_signals[NO_MORE_PADS], 0);

}

static gint

pad_compare_name (GstPad * pad1, const gchar * name)

{

  gint result;

  GST_OBJECT_LOCK (pad1);

  result = strcmp (GST_PAD_NAME (pad1), name);

  GST_OBJECT_UNLOCK (pad1);