gst/gstpad.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wtay@chello.be>
   4  *
   5  * gstpad.c: Pads for linking elements together
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22 /**
  23  * SECTION:gstpad
  24  * @short_description: Object contained by elements that allows links to
  25  *                     other elements
  26  * @see_also: #GstPadTemplate, #GstElement, #GstEvent
  27  *
  28  * A #GstElement is linked to other elements via "pads", which are extremely
  29  * light-weight generic link points.
  30  * After two pads are retrieved from an element with gst_element_get_pad(),
  31  * the pads can be link with gst_pad_link(). (For quick links,
  32  * you can also use gst_element_link(), which will make the obvious
  33  * link for you if it's straightforward.)
  34  *
  35  * Pads are typically created from a #GstPadTemplate with
  36  * gst_pad_new_from_template().
  37  *
  38  * Pads have #GstCaps attached to it to describe the media type they are
  39  * capable of dealing with.  gst_pad_get_caps() and gst_pad_set_caps() are
  40  * used to manipulate the caps of the pads.
  41  * Pads created from a pad template cannot set capabilities that are
  42  * incompatible with the pad template capabilities.
  43  *
  44  * Pads without pad templates can be created with gst_pad_new(),
  45  * which takes a direction and a name as an argument.  If the name is NULL,
  46  * then a guaranteed unique name will be assigned to it.
  47  *
  48  * gst_pad_get_parent() will retrieve the #GstElement that owns the pad.
  49  *
  50  * A #GstElement creating a pad will typically use the various
  51  * gst_pad_set_*_function() calls to register callbacks for various events
  52  * on the pads.
  53  *
  54  * GstElements will use gst_pad_push() and gst_pad_pull_range() to push out
  55  * or pull in a buffer.
  56  *
  57  * To send a #GstEvent on a pad, use gst_pad_send_event() and
  58  * gst_pad_push_event().
  59  *
  60  * Last reviewed on 2006-07-06 (0.10.9)
  61  */
  62
  63 #include "gst_private.h"
  64
  65 #include "gstpad.h"
  66 #include "gstpadtemplate.h"
  67 #include "gstenumtypes.h"
  68 #include "gstmarshal.h"
  69 #include "gstutils.h"
  70 #include "gstinfo.h"
  71 #include "gsterror.h"
  72 #include "gstvalue.h"
  73 #include "glib-compat-private.h"
  74
  75 GST_DEBUG_CATEGORY_STATIC (debug_dataflow);
  76 #define GST_CAT_DEFAULT GST_CAT_PADS
  77
  78 /* Pad signals and args */
  79 enum
  80 {
  81   PAD_LINKED,
  82   PAD_UNLINKED,
  83   PAD_REQUEST_LINK,
  84   PAD_HAVE_DATA,
  85   /* FILL ME */
  86   LAST_SIGNAL
  87 };
  88
  89 enum
  90 {
  91   PAD_PROP_0,
  92   PAD_PROP_CAPS,
  93   PAD_PROP_DIRECTION,
  94   PAD_PROP_TEMPLATE,
  95   /* FILL ME */
  96 };
  97
  98 #define GST_PAD_GET_PRIVATE(obj)  \
  99    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_PAD, GstPadPrivate))
 100
 101 #define GST_PAD_CHAINLISTFUNC(pad) ((pad)->abidata.ABI.priv->chainlistfunc)
 102
 103 struct _GstPadPrivate
 104 {
 105   GstPadChainListFunction chainlistfunc;
 106 };
 107
 108 static void gst_pad_dispose (GObject * object);
 109 static void gst_pad_finalize (GObject * object);
 110 static void gst_pad_set_property (GObject * object, guint prop_id,
 111     const GValue * value, GParamSpec * pspec);
 112 static void gst_pad_get_property (GObject * object, guint prop_id,
 113     GValue * value, GParamSpec * pspec);
 114
 115 static GstFlowReturn handle_pad_block (GstPad * pad);
 116 static GstCaps *gst_pad_get_caps_unlocked (GstPad * pad);
 117 static void gst_pad_set_pad_template (GstPad * pad, GstPadTemplate * templ);
 118 static gboolean gst_pad_activate_default (GstPad * pad);
 119 static gboolean gst_pad_acceptcaps_default (GstPad * pad, GstCaps * caps);
 120
 121 #if !defined(GST_DISABLE_LOADSAVE) && !defined(GST_REMOVE_DEPRECATED)
 122 #ifdef GST_DISABLE_DEPRECATED
 123 #include <libxml/parser.h>
 124 #endif
 125 static xmlNodePtr gst_pad_save_thyself (GstObject * object, xmlNodePtr parent);
 126 void gst_pad_load_and_link (xmlNodePtr self, GstObject * parent);
 127 #endif
 128
 129 /* Some deprecated stuff that we need inside here for
 130  * backwards compatibility */
 131 #ifdef GST_DISABLE_DEPRECATED
 132 #ifndef GST_REMOVE_DEPRECATED
 133 #define GST_PAD_INTLINKFUNC(pad)        (GST_PAD_CAST(pad)->intlinkfunc)
 134 GList *gst_pad_get_internal_links_default (GstPad * pad);
 135 #endif
 136 #endif
 137
 138 static GstObjectClass *parent_class = NULL;
 139 static guint gst_pad_signals[LAST_SIGNAL] = { 0 };
 140
 141 /* quarks for probe signals */
 142 static GQuark buffer_quark;
 143 static GQuark event_quark;
 144
 145 typedef struct
 146 {
 147   const gint ret;
 148   const gchar *name;
 149   GQuark quark;
 150 } GstFlowQuarks;
 151
 152 static GstFlowQuarks flow_quarks[] = {
 153   {GST_FLOW_CUSTOM_SUCCESS, "custom-success", 0},
 154   {GST_FLOW_RESEND, "resend", 0},
 155   {GST_FLOW_OK, "ok", 0},
 156   {GST_FLOW_NOT_LINKED, "not-linked", 0},
 157   {GST_FLOW_WRONG_STATE, "wrong-state", 0},
 158   {GST_FLOW_UNEXPECTED, "unexpected", 0},
 159   {GST_FLOW_NOT_NEGOTIATED, "not-negotiated", 0},
 160   {GST_FLOW_ERROR, "error", 0},
 161   {GST_FLOW_NOT_SUPPORTED, "not-supported", 0},
 162   {GST_FLOW_CUSTOM_ERROR, "custom-error", 0}
 163 };
 164
 165 /**
 166  * gst_flow_get_name:
 167  * @ret: a #GstFlowReturn to get the name of.
 168  *
 169  * Gets a string representing the given flow return.
 170  *
 171  * Returns: a static string with the name of the flow return.
 172  */
 173 G_CONST_RETURN gchar *
 174 gst_flow_get_name (GstFlowReturn ret)
 175 {
 176   gint i;
 177
 178   ret = CLAMP (ret, GST_FLOW_CUSTOM_ERROR, GST_FLOW_CUSTOM_SUCCESS);
 179
 180   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {
 181     if (ret == flow_quarks[i].ret)
 182       return flow_quarks[i].name;
 183   }
 184   return "unknown";
 185 }
 186
 187 /**
 188  * gst_flow_to_quark:
 189  * @ret: a #GstFlowReturn to get the quark of.
 190  *
 191  * Get the unique quark for the given GstFlowReturn.
 192  *
 193  * Returns: the quark associated with the flow return or 0 if an
 194  * invalid return was specified.
 195  */
 196 GQuark
 197 gst_flow_to_quark (GstFlowReturn ret)
 198 {
 199   gint i;
 200
 201   ret = CLAMP (ret, GST_FLOW_CUSTOM_ERROR, GST_FLOW_CUSTOM_SUCCESS);
 202
 203   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {
 204     if (ret == flow_quarks[i].ret)
 205       return flow_quarks[i].quark;
 206   }
 207   return 0;
 208 }
 209
 210 #define _do_init \
 211 { \
 212   gint i; \
 213   \
 214   buffer_quark = g_quark_from_static_string ("buffer"); \
 215   event_quark = g_quark_from_static_string ("event"); \
 216   \
 217   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {                    \
 218     flow_quarks[i].quark = g_quark_from_static_string (flow_quarks[i].name); \
 219   } \
 220   \
 221   GST_DEBUG_CATEGORY_INIT (debug_dataflow, "GST_DATAFLOW", \
 222       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "dataflow inside pads"); \
 223 }
 224
 225 G_DEFINE_TYPE_WITH_CODE (GstPad, gst_pad, GST_TYPE_OBJECT, _do_init);
 226
 227 static gboolean
 228 _gst_do_pass_data_accumulator (GSignalInvocationHint * ihint,
 229     GValue * return_accu, const GValue * handler_return, gpointer dummy)
 230 {
 231   gboolean ret = g_value_get_boolean (handler_return);
 232
 233   GST_DEBUG ("accumulated %d", ret);
 234   g_value_set_boolean (return_accu, ret);
 235
 236   return ret;
 237 }
 238
 239 static gboolean
 240 default_have_data (GstPad * pad, GstMiniObject * o)
 241 {
 242   return TRUE;
 243 }
 244
 245 static void
 246 gst_pad_class_init (GstPadClass * klass)
 247 {
 248   GObjectClass *gobject_class;
 249   GstObjectClass *gstobject_class;
 250
 251   gobject_class = G_OBJECT_CLASS (klass);
 252   gstobject_class = GST_OBJECT_CLASS (klass);
 253
 254   g_type_class_add_private (klass, sizeof (GstPadPrivate));
 255
 256   parent_class = g_type_class_peek_parent (klass);
 257
 258   gobject_class->dispose = gst_pad_dispose;
 259   gobject_class->finalize = gst_pad_finalize;
 260   gobject_class->set_property = gst_pad_set_property;
 261   gobject_class->get_property = gst_pad_get_property;
 262
 263   /**
 264    * GstPad::linked:
 265    * @pad: the pad that emitted the signal
 266    * @peer: the peer pad that has been connected
 267    *
 268    * Signals that a pad has been linked to the peer pad.
 269    */
 270   gst_pad_signals[PAD_LINKED] =
 271       g_signal_new ("linked", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 272       G_STRUCT_OFFSET (GstPadClass, linked), NULL, NULL,
 273       gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_PAD);
 274   /**
 275    * GstPad::unlinked:
 276    * @pad: the pad that emitted the signal
 277    * @peer: the peer pad that has been disconnected
 278    *
 279    * Signals that a pad has been unlinked from the peer pad.
 280    */
 281   gst_pad_signals[PAD_UNLINKED] =
 282       g_signal_new ("unlinked", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 283       G_STRUCT_OFFSET (GstPadClass, unlinked), NULL, NULL,
 284       gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_PAD);
 285   /**
 286    * GstPad::request-link:
 287    * @pad: the pad that emitted the signal
 288    * @peer: the peer pad for which a connection is requested
 289    *
 290    * Signals that a pad connection has been requested.
 291    */
 292   gst_pad_signals[PAD_REQUEST_LINK] =
 293       g_signal_new ("request-link", G_TYPE_FROM_CLASS (klass),
 294       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstPadClass, request_link), NULL,
 295       NULL, gst_marshal_VOID__OBJECT, G_TYPE_NONE, 0);
 296
 297   /**
 298    * GstPad::have-data:
 299    * @pad: the pad that emitted the signal
 300    * @mini_obj: new data
 301    *
 302    * Signals that new data is available on the pad. This signal is used
 303    * internally for implementing pad probes.
 304    * See gst_pad_add_*_probe functions.
 305    *
 306    * Returns: %TRUE to keep the data, %FALSE to drop it
 307    */
 308   gst_pad_signals[PAD_HAVE_DATA] =
 309       g_signal_new ("have-data", G_TYPE_FROM_CLASS (klass),
 310       G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 311       G_STRUCT_OFFSET (GstPadClass, have_data),
 312       _gst_do_pass_data_accumulator,
 313       NULL, gst_marshal_BOOLEAN__POINTER, G_TYPE_BOOLEAN, 1,
 314       GST_TYPE_MINI_OBJECT);
 315
 316   g_object_class_install_property (gobject_class, PAD_PROP_CAPS,
 317       g_param_spec_boxed ("caps", "Caps", "The capabilities of the pad",
 318           GST_TYPE_CAPS, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 319   g_object_class_install_property (gobject_class, PAD_PROP_DIRECTION,
 320       g_param_spec_enum ("direction", "Direction", "The direction of the pad",
 321           GST_TYPE_PAD_DIRECTION, GST_PAD_UNKNOWN,
 322           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
 323   /* FIXME, Make G_PARAM_CONSTRUCT_ONLY when we fix ghostpads. */
 324   g_object_class_install_property (gobject_class, PAD_PROP_TEMPLATE,
 325       g_param_spec_object ("template", "Template",
 326           "The GstPadTemplate of this pad", GST_TYPE_PAD_TEMPLATE,
 327           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 328
 329 #if !defined(GST_DISABLE_LOADSAVE) && !defined(GST_REMOVE_DEPRECATED)
 330   gstobject_class->save_thyself =
 331       ((gpointer (*)(GstObject * object,
 332               gpointer self)) * GST_DEBUG_FUNCPTR (gst_pad_save_thyself));
 333 #endif
 334   gstobject_class->path_string_separator = ".";
 335
 336   /* Register common function pointer descriptions */
 337   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_activate_default);
 338   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_event_default);
 339   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_get_query_types_default);
 340   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_query_default);
 341 #ifndef GST_REMOVE_DEPRECATED
 342   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_get_internal_links_default);
 343 #endif
 344   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_iterate_internal_links_default);
 345   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_acceptcaps_default);
 346
 347   klass->have_data = default_have_data;
 348 }
 349
 350 static void
 351 gst_pad_init (GstPad * pad)
 352 {
 353   pad->abidata.ABI.priv = GST_PAD_GET_PRIVATE (pad);
 354
 355   GST_PAD_DIRECTION (pad) = GST_PAD_UNKNOWN;
 356   GST_PAD_PEER (pad) = NULL;
 357
 358   GST_PAD_CHAINFUNC (pad) = NULL;
 359
 360   GST_PAD_LINKFUNC (pad) = NULL;
 361
 362   GST_PAD_CAPS (pad) = NULL;
 363   GST_PAD_GETCAPSFUNC (pad) = NULL;
 364
 365   GST_PAD_ACTIVATEFUNC (pad) = gst_pad_activate_default;
 366   GST_PAD_EVENTFUNC (pad) = gst_pad_event_default;
 367   GST_PAD_QUERYTYPEFUNC (pad) = gst_pad_get_query_types_default;
 368   GST_PAD_QUERYFUNC (pad) = gst_pad_query_default;
 369 #ifndef GST_REMOVE_DEPRECATED
 370   GST_PAD_INTLINKFUNC (pad) = gst_pad_get_internal_links_default;
 371 #endif
 372   GST_PAD_ITERINTLINKFUNC (pad) = gst_pad_iterate_internal_links_default;
 373
 374   GST_PAD_ACCEPTCAPSFUNC (pad) = gst_pad_acceptcaps_default;
 375
 376   pad->do_buffer_signals = 0;
 377   pad->do_event_signals = 0;
 378
 379   GST_PAD_SET_FLUSHING (pad);
 380
 381   pad->preroll_lock = g_mutex_new ();
 382   pad->preroll_cond = g_cond_new ();
 383
 384   /* FIXME 0.11: Store this directly in the instance struct */
 385   pad->stream_rec_lock = g_slice_new (GStaticRecMutex);
 386   g_static_rec_mutex_init (pad->stream_rec_lock);
 387
 388   pad->block_cond = g_cond_new ();
 389 }
 390
 391 static void
 392 gst_pad_dispose (GObject * object)
 393 {
 394   GstPad *pad = GST_PAD_CAST (object);
 395   GstPad *peer;
 396
 397   GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, pad, "dispose");
 398
 399   /* unlink the peer pad */
 400   if ((peer = gst_pad_get_peer (pad))) {
 401     /* window for MT unsafeness, someone else could unlink here
 402      * and then we call unlink with wrong pads. The unlink
 403      * function would catch this and safely return failed. */
 404     if (GST_PAD_IS_SRC (pad))
 405       gst_pad_unlink (pad, peer);
 406     else
 407       gst_pad_unlink (peer, pad);
 408
 409     gst_object_unref (peer);
 410   }
 411
 412   /* clear the caps */
 413   gst_caps_replace (&GST_PAD_CAPS (pad), NULL);
 414
 415   gst_pad_set_pad_template (pad, NULL);
 416
 417   if (pad->block_destroy_data && pad->block_data) {
 418     pad->block_destroy_data (pad->block_data);
 419     pad->block_data = NULL;
 420   }
 421
 422   G_OBJECT_CLASS (parent_class)->dispose (object);
 423 }
 424
 425 static void
 426 gst_pad_finalize (GObject * object)
 427 {
 428   GstPad *pad = GST_PAD_CAST (object);
 429   GstTask *task;
 430
 431   /* in case the task is still around, clean it up */
 432   if ((task = GST_PAD_TASK (pad))) {
 433     gst_task_join (task);
 434     GST_PAD_TASK (pad) = NULL;
 435     gst_object_unref (task);
 436   }
 437
 438   if (pad->stream_rec_lock) {
 439     g_static_rec_mutex_free (pad->stream_rec_lock);
 440     g_slice_free (GStaticRecMutex, pad->stream_rec_lock);
 441     pad->stream_rec_lock = NULL;
 442   }
 443   if (pad->preroll_lock) {
 444     g_mutex_free (pad->preroll_lock);
 445     g_cond_free (pad->preroll_cond);
 446     pad->preroll_lock = NULL;
 447     pad->preroll_cond = NULL;
 448   }
 449   if (pad->block_cond) {
 450     g_cond_free (pad->block_cond);
 451     pad->block_cond = NULL;
 452   }
 453
 454   G_OBJECT_CLASS (parent_class)->finalize (object);
 455 }
 456
 457 static void
 458 gst_pad_set_property (GObject * object, guint prop_id,
 459     const GValue * value, GParamSpec * pspec)
 460 {
 461   g_return_if_fail (GST_IS_PAD (object));
 462
 463   switch (prop_id) {
 464     case PAD_PROP_DIRECTION:
 465       GST_PAD_DIRECTION (object) = g_value_get_enum (value);
 466       break;
 467     case PAD_PROP_TEMPLATE:
 468       gst_pad_set_pad_template (GST_PAD_CAST (object),
 469           (GstPadTemplate *) g_value_get_object (value));
 470       break;
 471     default:
 472       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 473       break;
 474   }
 475 }
 476
 477 static void
 478 gst_pad_get_property (GObject * object, guint prop_id,
 479     GValue * value, GParamSpec * pspec)
 480 {
 481   g_return_if_fail (GST_IS_PAD (object));
 482
 483   switch (prop_id) {
 484     case PAD_PROP_CAPS:
 485       GST_OBJECT_LOCK (object);
 486       g_value_set_boxed (value, GST_PAD_CAPS (object));
 487       GST_OBJECT_UNLOCK (object);
 488       break;
 489     case PAD_PROP_DIRECTION:
 490       g_value_set_enum (value, GST_PAD_DIRECTION (object));
 491       break;
 492     case PAD_PROP_TEMPLATE:
 493       g_value_set_object (value, GST_PAD_PAD_TEMPLATE (object));
 494       break;
 495     default:
 496       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 497       break;
 498   }
 499 }
 500
 501 /**
 502  * gst_pad_new:
 503  * @name: the name of the new pad.
 504  * @direction: the #GstPadDirection of the pad.
 505  *
 506  * Creates a new pad with the given name in the given direction.
 507  * If name is NULL, a guaranteed unique name (across all pads)
 508  * will be assigned.
 509  * This function makes a copy of the name so you can safely free the name.
 510  *
 511  * Returns: a new #GstPad, or NULL in case of an error.
 512  *
 513  * MT safe.
 514  */
 515 GstPad *
 516 gst_pad_new (const gchar * name, GstPadDirection direction)
 517 {
 518   return g_object_new (GST_TYPE_PAD,
 519       "name", name, "direction", direction, NULL);
 520 }
 521
 522 /**
 523  * gst_pad_new_from_template:
 524  * @templ: the pad template to use
 525  * @name: the name of the element
 526  *
 527  * Creates a new pad with the given name from the given template.
 528  * If name is NULL, a guaranteed unique name (across all pads)
 529  * will be assigned.
 530  * This function makes a copy of the name so you can safely free the name.
 531  *
 532  * Returns: a new #GstPad, or NULL in case of an error.
 533  */
 534 GstPad *
 535 gst_pad_new_from_template (GstPadTemplate * templ, const gchar * name)
 536 {
 537   g_return_val_if_fail (GST_IS_PAD_TEMPLATE (templ), NULL);
 538
 539   return g_object_new (GST_TYPE_PAD,
 540       "name", name, "direction", templ->direction, "template", templ, NULL);
 541 }
 542
 543 /**
 544  * gst_pad_new_from_static_template:
 545  * @templ: the #GstStaticPadTemplate to use
 546  * @name: the name of the element
 547  *
 548  * Creates a new pad with the given name from the given static template.
 549  * If name is NULL, a guaranteed unique name (across all pads)
 550  * will be assigned.
 551  * This function makes a copy of the name so you can safely free the name.
 552  *
 553  * Returns: a new #GstPad, or NULL in case of an error.
 554  */
 555 GstPad *
 556 gst_pad_new_from_static_template (GstStaticPadTemplate * templ,
 557     const gchar * name)
 558 {
 559   GstPad *pad;
 560   GstPadTemplate *template;
 561
 562   template = gst_static_pad_template_get (templ);
 563   pad = gst_pad_new_from_template (template, name);
 564   gst_object_unref (template);
 565   return pad;
 566 }
 567
 568 /**
 569  * gst_pad_get_direction:
 570  * @pad: a #GstPad to get the direction of.
 571  *
 572  * Gets the direction of the pad. The direction of the pad is
 573  * decided at construction time so this function does not take
 574  * the LOCK.
 575  *
 576  * Returns: the #GstPadDirection of the pad.
 577  *
 578  * MT safe.
 579  */
 580 GstPadDirection
 581 gst_pad_get_direction (GstPad * pad)
 582 {
 583   GstPadDirection result;
 584
 585   /* PAD_UNKNOWN is a little silly but we need some sort of
 586    * error return value */
 587   g_return_val_if_fail (GST_IS_PAD (pad), GST_PAD_UNKNOWN);
 588
 589   result = GST_PAD_DIRECTION (pad);
 590
 591   return result;
 592 }
 593
 594 static gboolean
 595 gst_pad_activate_default (GstPad * pad)
 596 {
 597   return gst_pad_activate_push (pad, TRUE);
 598 }
 599
 600 static void
 601 pre_activate (GstPad * pad, GstActivateMode new_mode)
 602 {
 603   switch (new_mode) {
 604     case GST_ACTIVATE_PUSH:
 605     case GST_ACTIVATE_PULL:
 606       GST_OBJECT_LOCK (pad);
 607       GST_DEBUG_OBJECT (pad, "setting ACTIVATE_MODE %d, unset flushing",
 608           new_mode);
 609       GST_PAD_UNSET_FLUSHING (pad);
 610       GST_PAD_ACTIVATE_MODE (pad) = new_mode;
 611       GST_OBJECT_UNLOCK (pad);
 612       break;
 613     case GST_ACTIVATE_NONE:
 614       GST_OBJECT_LOCK (pad);
 615       GST_DEBUG_OBJECT (pad, "setting ACTIVATE_MODE NONE, set flushing");
 616       GST_PAD_SET_FLUSHING (pad);
 617       GST_PAD_ACTIVATE_MODE (pad) = new_mode;
 618       /* unlock blocked pads so element can resume and stop */
 619       GST_PAD_BLOCK_BROADCAST (pad);
 620       GST_OBJECT_UNLOCK (pad);
 621       break;
 622   }
 623 }
 624
 625 static void
 626 post_activate (GstPad * pad, GstActivateMode new_mode)
 627 {
 628   switch (new_mode) {
 629     case GST_ACTIVATE_PUSH:
 630     case GST_ACTIVATE_PULL:
 631       /* nop */
 632       break;
 633     case GST_ACTIVATE_NONE:
 634       /* ensures that streaming stops */
 635       GST_PAD_STREAM_LOCK (pad);
 636       GST_DEBUG_OBJECT (pad, "stopped streaming");
 637       GST_PAD_STREAM_UNLOCK (pad);
 638       break;
 639   }
 640 }
 641
 642 /**
 643  * gst_pad_set_active:
 644  * @pad: the #GstPad to activate or deactivate.
 645  * @active: whether or not the pad should be active.
 646  *
 647  * Activates or deactivates the given pad.
 648  * Normally called from within core state change functions.
 649  *
 650  * If @active, makes sure the pad is active. If it is already active, either in
 651  * push or pull mode, just return. Otherwise dispatches to the pad's activate
 652  * function to perform the actual activation.
 653  *
 654  * If not @active, checks the pad's current mode and calls
 655  * gst_pad_activate_push() or gst_pad_activate_pull(), as appropriate, with a
 656  * FALSE argument.
 657  *
 658  * Returns: #TRUE if the operation was successful.
 659  *
 660  * MT safe.
 661  */
 662 gboolean
 663 gst_pad_set_active (GstPad * pad, gboolean active)
 664 {
 665   GstActivateMode old;
 666   gboolean ret = FALSE;
 667
 668   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
 669
 670   GST_OBJECT_LOCK (pad);
 671   old = GST_PAD_ACTIVATE_MODE (pad);
 672   GST_OBJECT_UNLOCK (pad);
 673
 674   if (active) {
 675     switch (old) {
 676       case GST_ACTIVATE_PUSH:
 677         GST_DEBUG_OBJECT (pad, "activating pad from push");
 678         ret = TRUE;
 679         break;
 680       case GST_ACTIVATE_PULL:
 681         GST_DEBUG_OBJECT (pad, "activating pad from pull");
 682         ret = TRUE;
 683         break;
 684       case GST_ACTIVATE_NONE:
 685         GST_DEBUG_OBJECT (pad, "activating pad from none");
 686         ret = (GST_PAD_ACTIVATEFUNC (pad)) (pad);
 687         break;
 688     }
 689   } else {
 690     switch (old) {
 691       case GST_ACTIVATE_PUSH:
 692         GST_DEBUG_OBJECT (pad, "deactivating pad from push");
 693         ret = gst_pad_activate_push (pad, FALSE);
 694         break;
 695       case GST_ACTIVATE_PULL:
 696         GST_DEBUG_OBJECT (pad, "deactivating pad from pull");
 697         ret = gst_pad_activate_pull (pad, FALSE);
 698         break;
 699       case GST_ACTIVATE_NONE:
 700         GST_DEBUG_OBJECT (pad, "deactivating pad from none");
 701         ret = TRUE;
 702         break;
 703     }
 704   }
 705
 706   if (!ret) {
 707     GST_OBJECT_LOCK (pad);
 708     if (!active) {
 709       g_critical ("Failed to deactivate pad %s:%s, very bad",
 710           GST_DEBUG_PAD_NAME (pad));
 711     } else {
 712       GST_WARNING_OBJECT (pad, "Failed to activate pad");
 713     }
 714     GST_OBJECT_UNLOCK (pad);
 715   }
 716
 717   return ret;
 718 }
 719
 720 /**
 721  * gst_pad_activate_pull:
 722  * @pad: the #GstPad to activate or deactivate.
 723  * @active: whether or not the pad should be active.
 724  *
 725  * Activates or deactivates the given pad in pull mode via dispatching to the
 726  * pad's activatepullfunc. For use from within pad activation functions only.
 727  * When called on sink pads, will first proxy the call to the peer pad, which
 728  * is expected to activate its internally linked pads from within its
 729  * activate_pull function.
 730  *
 731  * If you don't know what this is, you probably don't want to call it.
 732  *
 733  * Returns: TRUE if the operation was successful.
 734  *
 735  * MT safe.
 736  */
 737 gboolean
 738 gst_pad_activate_pull (GstPad * pad, gboolean active)
 739 {
 740   GstActivateMode old, new;
 741   GstPad *peer;
 742
 743   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
 744
 745   GST_OBJECT_LOCK (pad);
 746   old = GST_PAD_ACTIVATE_MODE (pad);
 747   GST_OBJECT_UNLOCK (pad);
 748
 749   if (active) {
 750     switch (old) {
 751       case GST_ACTIVATE_PULL:
 752         GST_DEBUG_OBJECT (pad, "activating pad from pull, was ok");
 753         goto was_ok;
 754       case GST_ACTIVATE_PUSH:
 755         GST_DEBUG_OBJECT (pad,
 756             "activating pad from push, deactivate push first");
 757         /* pad was activate in the wrong direction, deactivate it
 758          * and reactivate it in pull mode */
 759         if (G_UNLIKELY (!gst_pad_activate_push (pad, FALSE)))
 760           goto deactivate_failed;
 761         /* fallthrough, pad is deactivated now. */
 762       case GST_ACTIVATE_NONE:
 763         GST_DEBUG_OBJECT (pad, "activating pad from none");
 764         break;
 765     }
 766   } else {
 767     switch (old) {
 768       case GST_ACTIVATE_NONE:
 769         GST_DEBUG_OBJECT (pad, "deactivating pad from none, was ok");
 770         goto was_ok;
 771       case GST_ACTIVATE_PUSH:
 772         GST_DEBUG_OBJECT (pad, "deactivating pad from push, weird");
 773         /* pad was activated in the other direction, deactivate it
 774          * in push mode, this should not happen... */
 775         if (G_UNLIKELY (!gst_pad_activate_push (pad, FALSE)))
 776           goto deactivate_failed;
 777         /* everything is fine now */
 778         goto was_ok;
 779       case GST_ACTIVATE_PULL:
 780         GST_DEBUG_OBJECT (pad, "deactivating pad from pull");
 781         break;
 782     }
 783   }
 784
 785   if (gst_pad_get_direction (pad) == GST_PAD_SINK) {
 786     if ((peer = gst_pad_get_peer (pad))) {
 787       GST_DEBUG_OBJECT (pad, "calling peer");
 788       if (G_UNLIKELY (!gst_pad_activate_pull (peer, active)))
 789         goto peer_failed;
 790       gst_object_unref (peer);
 791     } else {
 792       /* there is no peer, this is only fatal when we activate. When we
 793        * deactivate, we must assume the application has unlinked the peer and
 794        * will deactivate it eventually. */
 795       if (active)
 796         goto not_linked;
 797       else
 798         GST_DEBUG_OBJECT (pad, "deactivating unlinked pad");
 799     }
 800   } else {
 801     if (G_UNLIKELY (GST_PAD_GETRANGEFUNC (pad) == NULL))
 802       goto failure;             /* Can't activate pull on a src without a
 803                                    getrange function */
 804   }
 805
 806   new = active ? GST_ACTIVATE_PULL : GST_ACTIVATE_NONE;
 807   pre_activate (pad, new);
 808
 809   if (GST_PAD_ACTIVATEPULLFUNC (pad)) {
 810     if (G_UNLIKELY (!GST_PAD_ACTIVATEPULLFUNC (pad) (pad, active)))
 811       goto failure;
 812   } else {
 813     /* can happen for sinks of passthrough elements */
 814   }
 815
 816   post_activate (pad, new);
 817
 818   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "%s in pull mode",
 819       active ? "activated" : "deactivated");
 820
 821   return TRUE;
 822
 823 was_ok:
 824   {
 825     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "already %s in pull mode",
 826         active ? "activated" : "deactivated");
 827     return TRUE;
 828   }
 829 deactivate_failed:
 830   {
 831     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
 832         "failed to %s in switch to pull from mode %d",
 833         (active ? "activate" : "deactivate"), old);
 834     return FALSE;
 835   }
 836 peer_failed:
 837   {
 838     GST_OBJECT_LOCK (peer);
 839     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
 840         "activate_pull on peer (%s:%s) failed", GST_DEBUG_PAD_NAME (peer));
 841     GST_OBJECT_UNLOCK (peer);
 842     gst_object_unref (peer);
 843     return FALSE;
 844   }
 845 not_linked:
 846   {
 847     GST_CAT_INFO_OBJECT (GST_CAT_PADS, pad, "can't activate unlinked sink "
 848         "pad in pull mode");
 849     return FALSE;
 850   }
 851 failure:
 852   {
 853     GST_OBJECT_LOCK (pad);
 854     GST_CAT_INFO_OBJECT (GST_CAT_PADS, pad, "failed to %s in pull mode",
 855         active ? "activate" : "deactivate");
 856     GST_PAD_SET_FLUSHING (pad);
 857     GST_PAD_ACTIVATE_MODE (pad) = old;
 858     GST_OBJECT_UNLOCK (pad);
 859     return FALSE;
 860   }
 861 }
 862
 863 /**
 864  * gst_pad_activate_push:
 865  * @pad: the #GstPad to activate or deactivate.
 866  * @active: whether the pad should be active or not.
 867  *
 868  * Activates or deactivates the given pad in push mode via dispatching to the
 869  * pad's activatepushfunc. For use from within pad activation functions only.
 870  *
 871  * If you don't know what this is, you probably don't want to call it.
 872  *
 873  * Returns: %TRUE if the operation was successful.
 874  *
 875  * MT safe.
 876  */
 877 gboolean
 878 gst_pad_activate_push (GstPad * pad, gboolean active)
 879 {
 880   GstActivateMode old, new;
 881
 882   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
 883   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "trying to set %s in push mode",
 884       active ? "activated" : "deactivated");
 885
 886   GST_OBJECT_LOCK (pad);
 887   old = GST_PAD_ACTIVATE_MODE (pad);
 888   GST_OBJECT_UNLOCK (pad);
 889
 890   if (active) {
 891     switch (old) {
 892       case GST_ACTIVATE_PUSH:
 893         GST_DEBUG_OBJECT (pad, "activating pad from push, was ok");
 894         goto was_ok;
 895       case GST_ACTIVATE_PULL:
 896         GST_DEBUG_OBJECT (pad,
 897             "activating pad from push, deactivating pull first");
 898         /* pad was activate in the wrong direction, deactivate it
 899          * an reactivate it in push mode */
 900         if (G_UNLIKELY (!gst_pad_activate_pull (pad, FALSE)))
 901           goto deactivate_failed;
 902         /* fallthrough, pad is deactivated now. */
 903       case GST_ACTIVATE_NONE:
 904         GST_DEBUG_OBJECT (pad, "activating pad from none");
 905         break;
 906     }
 907   } else {
 908     switch (old) {
 909       case GST_ACTIVATE_NONE:
 910         GST_DEBUG_OBJECT (pad, "deactivating pad from none, was ok");
 911         goto was_ok;
 912       case GST_ACTIVATE_PULL:
 913         GST_DEBUG_OBJECT (pad, "deactivating pad from pull, weird");
 914         /* pad was activated in the other direction, deactivate it
 915          * in pull mode, this should not happen... */
 916         if (G_UNLIKELY (!gst_pad_activate_pull (pad, FALSE)))
 917           goto deactivate_failed;
 918         /* everything is fine now */
 919         goto was_ok;
 920       case GST_ACTIVATE_PUSH:
 921         GST_DEBUG_OBJECT (pad, "deactivating pad from push");
 922         break;
 923     }
 924   }
 925
 926   new = active ? GST_ACTIVATE_PUSH : GST_ACTIVATE_NONE;
 927   pre_activate (pad, new);
 928
 929   if (GST_PAD_ACTIVATEPUSHFUNC (pad)) {
 930     if (G_UNLIKELY (!GST_PAD_ACTIVATEPUSHFUNC (pad) (pad, active))) {
 931       goto failure;
 932     }
 933   } else {
 934     /* quite ok, element relies on state change func to prepare itself */
 935   }
 936
 937   post_activate (pad, new);
 938
 939   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "%s in push mode",
 940       active ? "activated" : "deactivated");
 941   return TRUE;
 942
 943 was_ok:
 944   {
 945     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "already %s in push mode",
 946         active ? "activated" : "deactivated");
 947     return TRUE;
 948   }
 949 deactivate_failed:
 950   {
 951     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
 952         "failed to %s in switch to push from mode %d",
 953         (active ? "activate" : "deactivate"), old);
 954     return FALSE;
 955   }
 956 failure:
 957   {
 958     GST_OBJECT_LOCK (pad);
 959     GST_CAT_INFO_OBJECT (GST_CAT_PADS, pad, "failed to %s in push mode",
 960         active ? "activate" : "deactivate");
 961     GST_PAD_SET_FLUSHING (pad);
 962     GST_PAD_ACTIVATE_MODE (pad) = old;
 963     GST_OBJECT_UNLOCK (pad);
 964     return FALSE;
 965   }
 966 }
 967
 968 /**
 969  * gst_pad_is_active:
 970  * @pad: the #GstPad to query
 971  *
 972  * Query if a pad is active
 973  *
 974  * Returns: TRUE if the pad is active.
 975  *
 976  * MT safe.
 977  */
 978 gboolean
 979 gst_pad_is_active (GstPad * pad)
 980 {
 981   gboolean result = FALSE;
 982
 983   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
 984
 985   GST_OBJECT_LOCK (pad);
 986   result = GST_PAD_MODE_ACTIVATE (GST_PAD_ACTIVATE_MODE (pad));
 987   GST_OBJECT_UNLOCK (pad);
 988
 989   return result;
 990 }
 991
 992 /**
 993  * gst_pad_set_blocked_async_full:
 994  * @pad: the #GstPad to block or unblock
 995  * @blocked: boolean indicating whether the pad should be blocked or unblocked
 996  * @callback: #GstPadBlockCallback that will be called when the
 997  *            operation succeeds
 998  * @user_data: user data passed to the callback
 999  * @destroy_data: #GDestroyNotify for user_data
1000  *
1001  * Blocks or unblocks the dataflow on a pad. The provided callback
1002  * is called when the operation succeeds; this happens right before the next
1003  * attempt at pushing a buffer on the pad.
1004  *
1005  * This can take a while as the pad can only become blocked when real dataflow
1006  * is happening.
1007  * When the pipeline is stalled, for example in PAUSED, this can
1008  * take an indeterminate amount of time.
1009  * You can pass NULL as the callback to make this call block. Be careful with
1010  * this blocking call as it might not return for reasons stated above.
1011  *
1012  * Returns: TRUE if the pad could be blocked. This function can fail if the
1013  * wrong parameters were passed or the pad was already in the requested state.
1014  *
1015  * MT safe.
1016  *
1017  * Since: 0.10.23
1018  */
1019 gboolean
1020 gst_pad_set_blocked_async_full (GstPad * pad, gboolean blocked,
1021     GstPadBlockCallback callback, gpointer user_data,
1022     GDestroyNotify destroy_data)
1023 {
1024   gboolean was_blocked = FALSE;
1025
1026   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1027
1028   GST_OBJECT_LOCK (pad);
1029
1030   was_blocked = GST_PAD_IS_BLOCKED (pad);
1031
1032   if (G_UNLIKELY (was_blocked == blocked))
1033     goto had_right_state;
1034
1035   if (blocked) {
1036     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "blocking pad");
1037
1038     GST_OBJECT_FLAG_SET (pad, GST_PAD_BLOCKED);
1039
1040     if (pad->block_destroy_data && pad->block_data)
1041       pad->block_destroy_data (pad->block_data);
1042
1043     pad->block_callback = callback;
1044     pad->block_data = user_data;
1045     pad->block_destroy_data = destroy_data;
1046     pad->abidata.ABI.block_callback_called = FALSE;
1047     if (!callback) {
1048       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "waiting for block");
1049       GST_PAD_BLOCK_WAIT (pad);
1050       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "blocked");
1051     }
1052   } else {
1053     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "unblocking pad");
1054
1055     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_BLOCKED);
1056
1057     if (pad->block_destroy_data && pad->block_data)
1058       pad->block_destroy_data (pad->block_data);
1059
1060     pad->block_callback = callback;
1061     pad->block_data = user_data;
1062     pad->block_destroy_data = destroy_data;
1063     pad->abidata.ABI.block_callback_called = FALSE;
1064
1065     GST_PAD_BLOCK_BROADCAST (pad);
1066     if (!callback) {
1067       /* no callback, wait for the unblock to happen */
1068       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "waiting for unblock");
1069       GST_PAD_BLOCK_WAIT (pad);
1070       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "unblocked");
1071     }
1072   }
1073   GST_OBJECT_UNLOCK (pad);
1074
1075   return TRUE;
1076
1077 had_right_state:
1078   {
1079     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
1080         "pad was in right state (%d)", was_blocked);
1081     GST_OBJECT_UNLOCK (pad);
1082
1083     return FALSE;
1084   }
1085 }
1086
1087 /**
1088  * gst_pad_set_blocked_async:
1089  * @pad: the #GstPad to block or unblock
1090  * @blocked: boolean indicating whether the pad should be blocked or unblocked
1091  * @callback: #GstPadBlockCallback that will be called when the
1092  *            operation succeeds
1093  * @user_data: user data passed to the callback
1094  *
1095  * Blocks or unblocks the dataflow on a pad. The provided callback
1096  * is called when the operation succeeds; this happens right before the next
1097  * attempt at pushing a buffer on the pad.
1098  *
1099  * This can take a while as the pad can only become blocked when real dataflow
1100  * is happening.
1101  * When the pipeline is stalled, for example in PAUSED, this can
1102  * take an indeterminate amount of time.
1103  * You can pass NULL as the callback to make this call block. Be careful with
1104  * this blocking call as it might not return for reasons stated above.
1105  *
1106  * Returns: TRUE if the pad could be blocked. This function can fail if the
1107  * wrong parameters were passed or the pad was already in the requested state.
1108  *
1109  * MT safe.
1110  */
1111 gboolean
1112 gst_pad_set_blocked_async (GstPad * pad, gboolean blocked,
1113     GstPadBlockCallback callback, gpointer user_data)
1114 {
1115   return gst_pad_set_blocked_async_full (pad, blocked,
1116       callback, user_data, NULL);
1117 }
1118
1119 /**
1120  * gst_pad_set_blocked:
1121  * @pad: the #GstPad to block or unblock
1122  * @blocked: boolean indicating we should block or unblock
1123  *
1124  * Blocks or unblocks the dataflow on a pad. This function is
1125  * a shortcut for gst_pad_set_blocked_async() with a NULL
1126  * callback.
1127  *
1128  * Returns: TRUE if the pad could be blocked. This function can fail if the
1129  * wrong parameters were passed or the pad was already in the requested state.
1130  *
1131  * MT safe.
1132  */
1133 gboolean
1134 gst_pad_set_blocked (GstPad * pad, gboolean blocked)
1135 {
1136   return gst_pad_set_blocked_async (pad, blocked, NULL, NULL);
1137 }
1138
1139 /**
1140  * gst_pad_is_blocked:
1141  * @pad: the #GstPad to query
1142  *
1143  * Checks if the pad is blocked or not. This function returns the
1144  * last requested state of the pad. It is not certain that the pad
1145  * is actually blocking at this point (see gst_pad_is_blocking()).
1146  *
1147  * Returns: TRUE if the pad is blocked.
1148  *
1149  * MT safe.
1150  */
1151 gboolean
1152 gst_pad_is_blocked (GstPad * pad)
1153 {
1154   gboolean result = FALSE;
1155
1156   g_return_val_if_fail (GST_IS_PAD (pad), result);
1157
1158   GST_OBJECT_LOCK (pad);
1159   result = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_BLOCKED);
1160   GST_OBJECT_UNLOCK (pad);
1161
1162   return result;
1163 }
1164
1165 /**
1166  * gst_pad_is_blocking:
1167  * @pad: the #GstPad to query
1168  *
1169  * Checks if the pad is blocking or not. This is a guaranteed state
1170  * of whether the pad is actually blocking on a #GstBuffer or a #GstEvent.
1171  *
1172  * Returns: TRUE if the pad is blocking.
1173  *
1174  * MT safe.
1175  *
1176  * Since: 0.10.11
1177  */
1178 gboolean
1179 gst_pad_is_blocking (GstPad * pad)
1180 {
1181   gboolean result = FALSE;
1182
1183   g_return_val_if_fail (GST_IS_PAD (pad), result);
1184
1185   GST_OBJECT_LOCK (pad);
1186   /* the blocking flag is only valid if the pad is not flushing */
1187   result = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_BLOCKING) &&
1188       !GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLUSHING);
1189   GST_OBJECT_UNLOCK (pad);
1190
1191   return result;
1192 }
1193
1194 /**
1195  * gst_pad_set_activate_function:
1196  * @pad: a #GstPad.
1197  * @activate: the #GstPadActivateFunction to set.
1198  *
1199  * Sets the given activate function for @pad. The activate function will
1200  * dispatch to gst_pad_activate_push() or gst_pad_activate_pull() to perform
1201  * the actual activation. Only makes sense to set on sink pads.
1202  *
1203  * Call this function if your sink pad can start a pull-based task.
1204  */
1205 void
1206 gst_pad_set_activate_function (GstPad * pad, GstPadActivateFunction activate)
1207 {
1208   g_return_if_fail (GST_IS_PAD (pad));
1209
1210   GST_PAD_ACTIVATEFUNC (pad) = activate;
1211   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "activatefunc set to %s",
1212       GST_DEBUG_FUNCPTR_NAME (activate));
1213 }
1214
1215 /**
1216  * gst_pad_set_activatepull_function:
1217  * @pad: a #GstPad.
1218  * @activatepull: the #GstPadActivateModeFunction to set.
1219  *
1220  * Sets the given activate_pull function for the pad. An activate_pull function
1221  * prepares the element and any upstream connections for pulling. See XXX
1222  * part-activation.txt for details.
1223  */
1224 void
1225 gst_pad_set_activatepull_function (GstPad * pad,
1226     GstPadActivateModeFunction activatepull)
1227 {
1228   g_return_if_fail (GST_IS_PAD (pad));
1229
1230   GST_PAD_ACTIVATEPULLFUNC (pad) = activatepull;
1231   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "activatepullfunc set to %s",
1232       GST_DEBUG_FUNCPTR_NAME (activatepull));
1233 }
1234
1235 /**
1236  * gst_pad_set_activatepush_function:
1237  * @pad: a #GstPad.
1238  * @activatepush: the #GstPadActivateModeFunction to set.
1239  *
1240  * Sets the given activate_push function for the pad. An activate_push function
1241  * prepares the element for pushing. See XXX part-activation.txt for details.
1242  */
1243 void
1244 gst_pad_set_activatepush_function (GstPad * pad,
1245     GstPadActivateModeFunction activatepush)
1246 {
1247   g_return_if_fail (GST_IS_PAD (pad));
1248
1249   GST_PAD_ACTIVATEPUSHFUNC (pad) = activatepush;
1250   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "activatepushfunc set to %s",
1251       GST_DEBUG_FUNCPTR_NAME (activatepush));
1252 }
1253
1254 /**
1255  * gst_pad_set_chain_function:
1256  * @pad: a sink #GstPad.
1257  * @chain: the #GstPadChainFunction to set.
1258  *
1259  * Sets the given chain function for the pad. The chain function is called to
1260  * process a #GstBuffer input buffer. see #GstPadChainFunction for more details.
1261  */
1262 void
1263 gst_pad_set_chain_function (GstPad * pad, GstPadChainFunction chain)
1264 {
1265   g_return_if_fail (GST_IS_PAD (pad));
1266   g_return_if_fail (GST_PAD_IS_SINK (pad));
1267
1268   GST_PAD_CHAINFUNC (pad) = chain;
1269   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "chainfunc set to %s",
1270       GST_DEBUG_FUNCPTR_NAME (chain));
1271 }
1272
1273 /**
1274  * gst_pad_set_chain_list_function:
1275  * @pad: a sink #GstPad.
1276  * @chainlist: the #GstPadChainListFunction to set.
1277  *
1278  * Sets the given chain list function for the pad. The chainlist function is
1279  * called to process a #GstBufferList input buffer list. See
1280  * #GstPadChainListFunction for more details.
1281  *
1282  * Since: 0.10.24
1283  */
1284 void
1285 gst_pad_set_chain_list_function (GstPad * pad,
1286     GstPadChainListFunction chainlist)
1287 {
1288   g_return_if_fail (GST_IS_PAD (pad));
1289   g_return_if_fail (GST_PAD_IS_SINK (pad));
1290
1291   GST_PAD_CHAINLISTFUNC (pad) = chainlist;
1292   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "chainlistfunc set to %s",
1293       GST_DEBUG_FUNCPTR_NAME (chainlist));
1294 }
1295
1296 /**
1297  * gst_pad_set_getrange_function:
1298  * @pad: a source #GstPad.
1299  * @get: the #GstPadGetRangeFunction to set.
1300  *
1301  * Sets the given getrange function for the pad. The getrange function is
1302  * called to produce a new #GstBuffer to start the processing pipeline. see
1303  * #GstPadGetRangeFunction for a description of the getrange function.
1304  */
1305 void
1306 gst_pad_set_getrange_function (GstPad * pad, GstPadGetRangeFunction get)
1307 {
1308   g_return_if_fail (GST_IS_PAD (pad));
1309   g_return_if_fail (GST_PAD_IS_SRC (pad));
1310
1311   GST_PAD_GETRANGEFUNC (pad) = get;
1312
1313   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "getrangefunc set to %s",
1314       GST_DEBUG_FUNCPTR_NAME (get));
1315 }
1316
1317 /**
1318  * gst_pad_set_checkgetrange_function:
1319  * @pad: a source #GstPad.
1320  * @check: the #GstPadCheckGetRangeFunction to set.
1321  *
1322  * Sets the given checkgetrange function for the pad. Implement this function
1323  * on a pad if you dynamically support getrange based scheduling on the pad.
1324  */
1325 void
1326 gst_pad_set_checkgetrange_function (GstPad * pad,
1327     GstPadCheckGetRangeFunction check)
1328 {
1329   g_return_if_fail (GST_IS_PAD (pad));
1330   g_return_if_fail (GST_PAD_IS_SRC (pad));
1331
1332   GST_PAD_CHECKGETRANGEFUNC (pad) = check;
1333
1334   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "checkgetrangefunc set to %s",
1335       GST_DEBUG_FUNCPTR_NAME (check));
1336 }
1337
1338 /**
1339  * gst_pad_set_event_function:
1340  * @pad: a #GstPad of either direction.
1341  * @event: the #GstPadEventFunction to set.
1342  *
1343  * Sets the given event handler for the pad.
1344  */
1345 void
1346 gst_pad_set_event_function (GstPad * pad, GstPadEventFunction event)
1347 {
1348   g_return_if_fail (GST_IS_PAD (pad));
1349
1350   GST_PAD_EVENTFUNC (pad) = event;
1351
1352   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "eventfunc for set to %s",
1353       GST_DEBUG_FUNCPTR_NAME (event));
1354 }
1355
1356 /**
1357  * gst_pad_set_query_function:
1358  * @pad: a #GstPad of either direction.
1359  * @query: the #GstPadQueryFunction to set.
1360  *
1361  * Set the given query function for the pad.
1362  */
1363 void
1364 gst_pad_set_query_function (GstPad * pad, GstPadQueryFunction query)
1365 {
1366   g_return_if_fail (GST_IS_PAD (pad));
1367
1368   GST_PAD_QUERYFUNC (pad) = query;
1369
1370   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "queryfunc set to %s",
1371       GST_DEBUG_FUNCPTR_NAME (query));
1372 }
1373
1374 /**
1375  * gst_pad_set_query_type_function:
1376  * @pad: a #GstPad of either direction.
1377  * @type_func: the #GstPadQueryTypeFunction to set.
1378  *
1379  * Set the given query type function for the pad.
1380  */
1381 void
1382 gst_pad_set_query_type_function (GstPad * pad,
1383     GstPadQueryTypeFunction type_func)
1384 {
1385   g_return_if_fail (GST_IS_PAD (pad));
1386
1387   GST_PAD_QUERYTYPEFUNC (pad) = type_func;
1388
1389   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "querytypefunc set to %s",
1390       GST_DEBUG_FUNCPTR_NAME (type_func));
1391 }
1392
1393 /**
1394  * gst_pad_get_query_types:
1395  * @pad: a #GstPad.
1396  *
1397  * Get an array of supported queries that can be performed
1398  * on this pad.
1399  *
1400  * Returns: a zero-terminated array of #GstQueryType.
1401  */
1402 const GstQueryType *
1403 gst_pad_get_query_types (GstPad * pad)
1404 {
1405   GstPadQueryTypeFunction func;
1406
1407   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1408
1409   if (G_UNLIKELY ((func = GST_PAD_QUERYTYPEFUNC (pad)) == NULL))
1410     goto no_func;
1411
1412   return func (pad);
1413
1414 no_func:
1415   {
1416     return NULL;
1417   }
1418 }
1419
1420 static gboolean
1421 gst_pad_get_query_types_dispatcher (GstPad * pad, const GstQueryType ** data)
1422 {
1423   *data = gst_pad_get_query_types (pad);
1424
1425   return TRUE;
1426 }
1427
1428 /**
1429  * gst_pad_get_query_types_default:
1430  * @pad: a #GstPad.
1431  *
1432  * Invoke the default dispatcher for the query types on
1433  * the pad.
1434  *
1435  * Returns: an zero-terminated array of #GstQueryType, or NULL if none of the
1436  * internally-linked pads has a query types function.
1437  */
1438 const GstQueryType *
1439 gst_pad_get_query_types_default (GstPad * pad)
1440 {
1441   GstQueryType *result = NULL;
1442
1443   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
1444
1445   gst_pad_dispatcher (pad, (GstPadDispatcherFunction)
1446       gst_pad_get_query_types_dispatcher, &result);
1447
1448   return result;
1449 }
1450
1451 /**
1452  * gst_pad_set_iterate_internal_links_function:
1453  * @pad: a #GstPad of either direction.
1454  * @iterintlink: the #GstPadIterIntLinkFunction to set.
1455  *
1456  * Sets the given internal link iterator function for the pad.
1457  *
1458  * Since: 0.10.21
1459  */
1460 void
1461 gst_pad_set_iterate_internal_links_function (GstPad * pad,
1462     GstPadIterIntLinkFunction iterintlink)
1463 {
1464   g_return_if_fail (GST_IS_PAD (pad));
1465
1466   GST_PAD_ITERINTLINKFUNC (pad) = iterintlink;
1467   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "internal link iterator set to %s",
1468       GST_DEBUG_FUNCPTR_NAME (iterintlink));
1469 }
1470
1471 /**
1472  * gst_pad_set_internal_link_function:
1473  * @pad: a #GstPad of either direction.
1474  * @intlink: the #GstPadIntLinkFunction to set.
1475  *
1476  * Sets the given internal link function for the pad.
1477  *
1478  * Deprecated: Use the thread-safe gst_pad_set_iterate_internal_links_function()
1479  */
1480 #ifndef GST_REMOVE_DEPRECATED
1481 #ifdef GST_DISABLE_DEPRECATED
1482 void
1483 gst_pad_set_internal_link_function (GstPad * pad,
1484     GstPadIntLinkFunction intlink);
1485 #endif
1486 void
1487 gst_pad_set_internal_link_function (GstPad * pad, GstPadIntLinkFunction intlink)
1488 {
1489   g_return_if_fail (GST_IS_PAD (pad));
1490
1491   GST_PAD_INTLINKFUNC (pad) = intlink;
1492   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "internal link set to %s",
1493       GST_DEBUG_FUNCPTR_NAME (intlink));
1494 }
1495 #endif /* GST_REMOVE_DEPRECATED */
1496
1497 /**
1498  * gst_pad_set_link_function:
1499  * @pad: a #GstPad.
1500  * @link: the #GstPadLinkFunction to set.
1501  *
1502  * Sets the given link function for the pad. It will be called when
1503  * the pad is linked with another pad.
1504  *
1505  * The return value #GST_PAD_LINK_OK should be used when the connection can be
1506  * made.
1507  *
1508  * The return value #GST_PAD_LINK_REFUSED should be used when the connection
1509  * cannot be made for some reason.
1510  *
1511  * If @link is installed on a source pad, it should call the #GstPadLinkFunction
1512  * of the peer sink pad, if present.
1513  */
1514 void
1515 gst_pad_set_link_function (GstPad * pad, GstPadLinkFunction link)
1516 {
1517   g_return_if_fail (GST_IS_PAD (pad));
1518
1519   GST_PAD_LINKFUNC (pad) = link;
1520   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "linkfunc set to %s",
1521       GST_DEBUG_FUNCPTR_NAME (link));
1522 }
1523
1524 /**
1525  * gst_pad_set_unlink_function:
1526  * @pad: a #GstPad.
1527  * @unlink: the #GstPadUnlinkFunction to set.
1528  *
1529  * Sets the given unlink function for the pad. It will be called
1530  * when the pad is unlinked.
1531  */
1532 void
1533 gst_pad_set_unlink_function (GstPad * pad, GstPadUnlinkFunction unlink)
1534 {
1535   g_return_if_fail (GST_IS_PAD (pad));
1536
1537   GST_PAD_UNLINKFUNC (pad) = unlink;
1538   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "unlinkfunc set to %s",
1539       GST_DEBUG_FUNCPTR_NAME (unlink));
1540 }
1541
1542 /**
1543  * gst_pad_set_getcaps_function:
1544  * @pad: a #GstPad.
1545  * @getcaps: the #GstPadGetCapsFunction to set.
1546  *
1547  * Sets the given getcaps function for the pad. @getcaps should return the
1548  * allowable caps for a pad in the context of the element's state, its link to
1549  * other elements, and the devices or files it has opened. These caps must be a
1550  * subset of the pad template caps. In the NULL state with no links, @getcaps
1551  * should ideally return the same caps as the pad template. In rare
1552  * circumstances, an object property can affect the caps returned by @getcaps,
1553  * but this is discouraged.
1554  *
1555  * You do not need to call this function if @pad's allowed caps are always the
1556  * same as the pad template caps. This can only be true if the padtemplate
1557  * has fixed simple caps.
1558  *
1559  * For most filters, the caps returned by @getcaps is directly affected by the
1560  * allowed caps on other pads. For demuxers and decoders, the caps returned by
1561  * the srcpad's getcaps function is directly related to the stream data. Again,
1562  * @getcaps should return the most specific caps it reasonably can, since this
1563  * helps with autoplugging.
1564  *
1565  * Note that the return value from @getcaps is owned by the caller, so the
1566  * caller should unref the caps after usage.
1567  */
1568 void
1569 gst_pad_set_getcaps_function (GstPad * pad, GstPadGetCapsFunction getcaps)
1570 {
1571   g_return_if_fail (GST_IS_PAD (pad));
1572
1573   GST_PAD_GETCAPSFUNC (pad) = getcaps;
1574   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "getcapsfunc set to %s",
1575       GST_DEBUG_FUNCPTR_NAME (getcaps));
1576 }
1577
1578 /**
1579  * gst_pad_set_acceptcaps_function:
1580  * @pad: a #GstPad.
1581  * @acceptcaps: the #GstPadAcceptCapsFunction to set.
1582  *
1583  * Sets the given acceptcaps function for the pad.  The acceptcaps function
1584  * will be called to check if the pad can accept the given caps. Setting the
1585  * acceptcaps function to NULL restores the default behaviour of allowing
1586  * any caps that matches the caps from gst_pad_get_caps().
1587  */
1588 void
1589 gst_pad_set_acceptcaps_function (GstPad * pad,
1590     GstPadAcceptCapsFunction acceptcaps)
1591 {
1592   g_return_if_fail (GST_IS_PAD (pad));
1593
1594   GST_PAD_ACCEPTCAPSFUNC (pad) = acceptcaps;
1595   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "acceptcapsfunc set to %s",
1596       GST_DEBUG_FUNCPTR_NAME (acceptcaps));
1597 }
1598
1599 /**
1600  * gst_pad_set_fixatecaps_function:
1601  * @pad: a #GstPad.
1602  * @fixatecaps: the #GstPadFixateCapsFunction to set.
1603  *
1604  * Sets the given fixatecaps function for the pad.  The fixatecaps function
1605  * will be called whenever the default values for a GstCaps needs to be
1606  * filled in.
1607  */
1608 void
1609 gst_pad_set_fixatecaps_function (GstPad * pad,
1610     GstPadFixateCapsFunction fixatecaps)
1611 {
1612   g_return_if_fail (GST_IS_PAD (pad));
1613
1614   GST_PAD_FIXATECAPSFUNC (pad) = fixatecaps;
1615   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "fixatecapsfunc set to %s",
1616       GST_DEBUG_FUNCPTR_NAME (fixatecaps));
1617 }
1618
1619 /**
1620  * gst_pad_set_setcaps_function:
1621  * @pad: a #GstPad.
1622  * @setcaps: the #GstPadSetCapsFunction to set.
1623  *
1624  * Sets the given setcaps function for the pad.  The setcaps function
1625  * will be called whenever a buffer with a new media type is pushed or
1626  * pulled from the pad. The pad/element needs to update its internal
1627  * structures to process the new media type. If this new type is not
1628  * acceptable, the setcaps function should return FALSE.
1629  */
1630 void
1631 gst_pad_set_setcaps_function (GstPad * pad, GstPadSetCapsFunction setcaps)
1632 {
1633   g_return_if_fail (GST_IS_PAD (pad));
1634
1635   GST_PAD_SETCAPSFUNC (pad) = setcaps;
1636   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "setcapsfunc set to %s",
1637       GST_DEBUG_FUNCPTR_NAME (setcaps));
1638 }
1639
1640 /**
1641  * gst_pad_set_bufferalloc_function:
1642  * @pad: a sink #GstPad.
1643  * @bufalloc: the #GstPadBufferAllocFunction to set.
1644  *
1645  * Sets the given bufferalloc function for the pad. Note that the
1646  * bufferalloc function can only be set on sinkpads.
1647  */
1648 void
1649 gst_pad_set_bufferalloc_function (GstPad * pad,
1650     GstPadBufferAllocFunction bufalloc)
1651 {
1652   g_return_if_fail (GST_IS_PAD (pad));
1653   g_return_if_fail (GST_PAD_IS_SINK (pad));
1654
1655   GST_PAD_BUFFERALLOCFUNC (pad) = bufalloc;
1656   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "bufferallocfunc set to %s",
1657       GST_DEBUG_FUNCPTR_NAME (bufalloc));
1658 }
1659
1660 /**
1661  * gst_pad_unlink:
1662  * @srcpad: the source #GstPad to unlink.
1663  * @sinkpad: the sink #GstPad to unlink.
1664  *
1665  * Unlinks the source pad from the sink pad. Will emit the #GstPad::unlinked
1666  * signal on both pads.
1667  *
1668  * Returns: TRUE if the pads were unlinked. This function returns FALSE if
1669  * the pads were not linked together.
1670  *
1671  * MT safe.
1672  */
1673 gboolean
1674 gst_pad_unlink (GstPad * srcpad, GstPad * sinkpad)
1675 {
1676   gboolean result = FALSE;
1677   GstElement *parent = NULL;
1678
1679   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
1680   g_return_val_if_fail (GST_PAD_IS_SRC (srcpad), FALSE);
1681   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
1682   g_return_val_if_fail (GST_PAD_IS_SINK (sinkpad), FALSE);
1683
1684   GST_CAT_INFO (GST_CAT_ELEMENT_PADS, "unlinking %s:%s(%p) and %s:%s(%p)",
1685       GST_DEBUG_PAD_NAME (srcpad), srcpad,
1686       GST_DEBUG_PAD_NAME (sinkpad), sinkpad);
1687
1688   /* We need to notify the parent before taking any pad locks as the bin in
1689    * question might be waiting for a lock on the pad while holding its lock
1690    * that our message will try to take. */
1691   if ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (srcpad)))) {
1692     if (GST_IS_ELEMENT (parent)) {
1693       gst_element_post_message (parent,
1694           gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
1695               GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK, parent, TRUE));
1696     } else {
1697       gst_object_unref (parent);
1698       parent = NULL;
1699     }
1700   }
1701
1702   GST_OBJECT_LOCK (srcpad);
1703
1704   GST_OBJECT_LOCK (sinkpad);
1705
1706   if (G_UNLIKELY (GST_PAD_PEER (srcpad) != sinkpad))
1707     goto not_linked_together;
1708
1709   if (GST_PAD_UNLINKFUNC (srcpad)) {
1710     GST_PAD_UNLINKFUNC (srcpad) (srcpad);
1711   }
1712   if (GST_PAD_UNLINKFUNC (sinkpad)) {
1713     GST_PAD_UNLINKFUNC (sinkpad) (sinkpad);
1714   }
1715
1716   /* first clear peers */
1717   GST_PAD_PEER (srcpad) = NULL;
1718   GST_PAD_PEER (sinkpad) = NULL;
1719
1720   GST_OBJECT_UNLOCK (sinkpad);
1721   GST_OBJECT_UNLOCK (srcpad);
1722
1723   /* fire off a signal to each of the pads telling them
1724    * that they've been unlinked */
1725   g_signal_emit (srcpad, gst_pad_signals[PAD_UNLINKED], 0, sinkpad);
1726   g_signal_emit (sinkpad, gst_pad_signals[PAD_UNLINKED], 0, srcpad);
1727
1728   GST_CAT_INFO (GST_CAT_ELEMENT_PADS, "unlinked %s:%s and %s:%s",
1729       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
1730
1731   result = TRUE;
1732
1733 done:
1734   if (parent != NULL) {
1735     gst_element_post_message (parent,
1736         gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
1737             GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK, parent, FALSE));
1738     gst_object_unref (parent);
1739   }
1740   return result;
1741
1742   /* ERRORS */
1743 not_linked_together:
1744   {
1745     /* we do not emit a warning in this case because unlinking cannot
1746      * be made MT safe.*/
1747     GST_OBJECT_UNLOCK (sinkpad);
1748     GST_OBJECT_UNLOCK (srcpad);
1749     goto done;
1750   }
1751 }
1752
1753 /**
1754  * gst_pad_is_linked:
1755  * @pad: pad to check
1756  *
1757  * Checks if a @pad is linked to another pad or not.
1758  *
1759  * Returns: TRUE if the pad is linked, FALSE otherwise.
1760  *
1761  * MT safe.
1762  */
1763 gboolean
1764 gst_pad_is_linked (GstPad * pad)
1765 {
1766   gboolean result;
1767
1768   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1769
1770   GST_OBJECT_LOCK (pad);
1771   result = (GST_PAD_PEER (pad) != NULL);
1772   GST_OBJECT_UNLOCK (pad);
1773
1774   return result;
1775 }
1776
1777 /* get the caps from both pads and see if the intersection
1778  * is not empty.
1779  *
1780  * This function should be called with the pad LOCK on both
1781  * pads
1782  */
1783 static gboolean
1784 gst_pad_link_check_compatible_unlocked (GstPad * src, GstPad * sink,
1785     GstPadLinkCheck flags)
1786 {
1787   GstCaps *srccaps = NULL;
1788   GstCaps *sinkcaps = NULL;
1789   gboolean compatible = FALSE;
1790
1791   if (!(flags & (GST_PAD_LINK_CHECK_CAPS | GST_PAD_LINK_CHECK_TEMPLATE_CAPS)))
1792     return TRUE;
1793
1794   /* Doing the expensive caps checking takes priority over only checking the template caps */
1795   if (flags & GST_PAD_LINK_CHECK_CAPS) {
1796     srccaps = gst_pad_get_caps_unlocked (src);
1797     sinkcaps = gst_pad_get_caps_unlocked (sink);
1798   } else {
1799     /* If one of the two pads doesn't have a template, consider the intersection
1800      * as valid.*/
1801     if (G_UNLIKELY ((GST_PAD_PAD_TEMPLATE (src) == NULL)
1802             || (GST_PAD_PAD_TEMPLATE (sink) == NULL))) {
1803       compatible = TRUE;
1804       goto done;
1805     }
1806     srccaps = gst_caps_ref (GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (src)));
1807     sinkcaps =
1808         gst_caps_ref (GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (sink)));
1809   }
1810
1811   GST_CAT_DEBUG (GST_CAT_CAPS, "src caps %" GST_PTR_FORMAT, srccaps);
1812   GST_CAT_DEBUG (GST_CAT_CAPS, "sink caps %" GST_PTR_FORMAT, sinkcaps);
1813
1814   /* if we have caps on both pads we can check the intersection. If one
1815    * of the caps is NULL, we return TRUE. */
1816   if (G_UNLIKELY (srccaps == NULL || sinkcaps == NULL)) {
1817     if (srccaps)
1818       gst_caps_unref (srccaps);
1819     if (sinkcaps)
1820       gst_caps_unref (sinkcaps);
1821     goto done;
1822   }
1823
1824   compatible = gst_caps_can_intersect (srccaps, sinkcaps);
1825   gst_caps_unref (srccaps);
1826   gst_caps_unref (sinkcaps);
1827
1828 done:
1829   GST_CAT_DEBUG (GST_CAT_CAPS, "caps are %scompatible",
1830       (compatible ? "" : "not"));
1831
1832   return compatible;
1833 }
1834
1835 /* check if the grandparents of both pads are the same.
1836  * This check is required so that we don't try to link
1837  * pads from elements in different bins without ghostpads.
1838  *
1839  * The LOCK should be held on both pads
1840  */
1841 static gboolean
1842 gst_pad_link_check_hierarchy (GstPad * src, GstPad * sink)
1843 {
1844   GstObject *psrc, *psink;
1845
1846   psrc = GST_OBJECT_PARENT (src);
1847   psink = GST_OBJECT_PARENT (sink);
1848
1849   /* if one of the pads has no parent, we allow the link */
1850   if (G_UNLIKELY (psrc == NULL || psink == NULL))
1851     goto no_parent;
1852
1853   /* only care about parents that are elements */
1854   if (G_UNLIKELY (!GST_IS_ELEMENT (psrc) || !GST_IS_ELEMENT (psink)))
1855     goto no_element_parent;
1856
1857   /* if the parents are the same, we have a loop */
1858   if (G_UNLIKELY (psrc == psink))
1859     goto same_parents;
1860
1861   /* if they both have a parent, we check the grandparents. We can not lock
1862    * the parent because we hold on the child (pad) and the locking order is
1863    * parent >> child. */
1864   psrc = GST_OBJECT_PARENT (psrc);
1865   psink = GST_OBJECT_PARENT (psink);
1866
1867   /* if they have grandparents but they are not the same */
1868   if (G_UNLIKELY (psrc != psink))
1869     goto wrong_grandparents;
1870
1871   return TRUE;
1872
1873   /* ERRORS */
1874 no_parent:
1875   {
1876     GST_CAT_DEBUG (GST_CAT_CAPS,
1877         "one of the pads has no parent %" GST_PTR_FORMAT " and %"
1878         GST_PTR_FORMAT, psrc, psink);
1879     return TRUE;
1880   }
1881 no_element_parent:
1882   {
1883     GST_CAT_DEBUG (GST_CAT_CAPS,
1884         "one of the pads has no element parent %" GST_PTR_FORMAT " and %"
1885         GST_PTR_FORMAT, psrc, psink);
1886     return TRUE;
1887   }
1888 same_parents:
1889   {
1890     GST_CAT_DEBUG (GST_CAT_CAPS, "pads have same parent %" GST_PTR_FORMAT,
1891         psrc);
1892     return FALSE;
1893   }
1894 wrong_grandparents:
1895   {
1896     GST_CAT_DEBUG (GST_CAT_CAPS,
1897         "pads have different grandparents %" GST_PTR_FORMAT " and %"
1898         GST_PTR_FORMAT, psrc, psink);
1899     return FALSE;
1900   }
1901 }
1902
1903 /* FIXME leftover from an attempt at refactoring... */
1904 /* call with the two pads unlocked, when this function returns GST_PAD_LINK_OK,
1905  * the two pads will be locked in the srcpad, sinkpad order. */
1906 static GstPadLinkReturn
1907 gst_pad_link_prepare (GstPad * srcpad, GstPad * sinkpad, GstPadLinkCheck flags)
1908 {
1909   GST_CAT_INFO (GST_CAT_PADS, "trying to link %s:%s and %s:%s",
1910       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
1911
1912   GST_OBJECT_LOCK (srcpad);
1913
1914   if (G_UNLIKELY (GST_PAD_PEER (srcpad) != NULL))
1915     goto src_was_linked;
1916
1917   GST_OBJECT_LOCK (sinkpad);
1918
1919   if (G_UNLIKELY (GST_PAD_PEER (sinkpad) != NULL))
1920     goto sink_was_linked;
1921
1922   /* check hierarchy, pads can only be linked if the grandparents
1923    * are the same. */
1924   if ((flags & GST_PAD_LINK_CHECK_HIERARCHY)
1925       && !gst_pad_link_check_hierarchy (srcpad, sinkpad))
1926     goto wrong_hierarchy;
1927
1928   /* check pad caps for non-empty intersection */
1929   if (!gst_pad_link_check_compatible_unlocked (srcpad, sinkpad, flags))
1930     goto no_format;
1931
1932   /* FIXME check pad scheduling for non-empty intersection */
1933
1934   return GST_PAD_LINK_OK;
1935
1936 src_was_linked:
1937   {
1938     GST_CAT_INFO (GST_CAT_PADS, "src %s:%s was already linked to %s:%s",
1939         GST_DEBUG_PAD_NAME (srcpad),
1940         GST_DEBUG_PAD_NAME (GST_PAD_PEER (srcpad)));
1941     /* we do not emit a warning in this case because unlinking cannot
1942      * be made MT safe.*/
1943     GST_OBJECT_UNLOCK (srcpad);
1944     return GST_PAD_LINK_WAS_LINKED;
1945   }
1946 sink_was_linked:
1947   {
1948     GST_CAT_INFO (GST_CAT_PADS, "sink %s:%s was already linked to %s:%s",
1949         GST_DEBUG_PAD_NAME (sinkpad),
1950         GST_DEBUG_PAD_NAME (GST_PAD_PEER (sinkpad)));
1951     /* we do not emit a warning in this case because unlinking cannot
1952      * be made MT safe.*/
1953     GST_OBJECT_UNLOCK (sinkpad);
1954     GST_OBJECT_UNLOCK (srcpad);
1955     return GST_PAD_LINK_WAS_LINKED;
1956   }
1957 wrong_hierarchy:
1958   {
1959     GST_CAT_INFO (GST_CAT_PADS, "pads have wrong hierarchy");
1960     GST_OBJECT_UNLOCK (sinkpad);
1961     GST_OBJECT_UNLOCK (srcpad);
1962     return GST_PAD_LINK_WRONG_HIERARCHY;
1963   }
1964 no_format:
1965   {
1966     GST_CAT_INFO (GST_CAT_PADS, "caps are incompatible");
1967     GST_OBJECT_UNLOCK (sinkpad);
1968     GST_OBJECT_UNLOCK (srcpad);
1969     return GST_PAD_LINK_NOFORMAT;
1970   }
1971 }
1972
1973 /**
1974  * gst_pad_can_link:
1975  * @srcpad: the source #GstPad.
1976  * @sinkpad: the sink #GstPad.
1977  *
1978  * Checks if the source pad and the sink pad are compatible so they can be
1979  * linked.
1980  *
1981  * Returns: TRUE if the pads can be linked.
1982  */
1983 gboolean
1984 gst_pad_can_link (GstPad * srcpad, GstPad * sinkpad)
1985 {
1986   GstPadLinkReturn result;
1987
1988   /* generic checks */
1989   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
1990   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
1991
1992   GST_CAT_INFO (GST_CAT_PADS, "check if %s:%s can link with %s:%s",
1993       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
1994
1995   /* gst_pad_link_prepare does everything for us, we only release the locks
1996    * on the pads that it gets us. If this function returns !OK the locks are not
1997    * taken anymore. */
1998   result = gst_pad_link_prepare (srcpad, sinkpad, GST_PAD_LINK_CHECK_DEFAULT);
1999   if (result != GST_PAD_LINK_OK)
2000     goto done;
2001
2002   GST_OBJECT_UNLOCK (srcpad);
2003   GST_OBJECT_UNLOCK (sinkpad);
2004
2005 done:
2006   return result == GST_PAD_LINK_OK;
2007 }
2008
2009 /**
2010  * gst_pad_link_full:
2011  * @srcpad: the source #GstPad to link.
2012  * @sinkpad: the sink #GstPad to link.
2013  * @flags: the checks to validate when linking
2014  *
2015  * Links the source pad and the sink pad.
2016  *
2017  * This variant of #gst_pad_link provides a more granular control on the
2018  * checks being done when linking. While providing some considerable speedups
2019  * the caller of this method must be aware that wrong usage of those flags
2020  * can cause severe issues. Refer to the documentation of #GstPadLinkCheck
2021  * for more information.
2022  *
2023  * Returns: A result code indicating if the connection worked or
2024  *          what went wrong.
2025  *
2026  * Since: 0.10.30
2027  *
2028  * MT Safe.
2029  */
2030 GstPadLinkReturn
2031 gst_pad_link_full (GstPad * srcpad, GstPad * sinkpad, GstPadLinkCheck flags)
2032 {
2033   GstPadLinkReturn result;
2034   GstElement *parent;
2035
2036   g_return_val_if_fail (GST_IS_PAD (srcpad), GST_PAD_LINK_REFUSED);
2037   g_return_val_if_fail (GST_PAD_IS_SRC (srcpad), GST_PAD_LINK_WRONG_DIRECTION);
2038   g_return_val_if_fail (GST_IS_PAD (sinkpad), GST_PAD_LINK_REFUSED);
2039   g_return_val_if_fail (GST_PAD_IS_SINK (sinkpad),
2040       GST_PAD_LINK_WRONG_DIRECTION);
2041
2042   /* Notify the parent early. See gst_pad_unlink for details. */
2043   if ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (srcpad)))) {
2044     if (GST_IS_ELEMENT (parent)) {
2045       gst_element_post_message (parent,
2046           gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2047               GST_STRUCTURE_CHANGE_TYPE_PAD_LINK, parent, TRUE));
2048     } else {
2049       gst_object_unref (parent);
2050       parent = NULL;
2051     }
2052   }
2053
2054   /* prepare will also lock the two pads */
2055   result = gst_pad_link_prepare (srcpad, sinkpad, flags);
2056
2057   if (result != GST_PAD_LINK_OK)
2058     goto done;
2059
2060   /* must set peers before calling the link function */
2061   GST_PAD_PEER (srcpad) = sinkpad;
2062   GST_PAD_PEER (sinkpad) = srcpad;
2063
2064   GST_OBJECT_UNLOCK (sinkpad);
2065   GST_OBJECT_UNLOCK (srcpad);
2066
2067   /* FIXME released the locks here, concurrent thread might link
2068    * something else. */
2069   if (GST_PAD_LINKFUNC (srcpad)) {
2070     /* this one will call the peer link function */
2071     result = GST_PAD_LINKFUNC (srcpad) (srcpad, sinkpad);
2072   } else if (GST_PAD_LINKFUNC (sinkpad)) {
2073     /* if no source link function, we need to call the sink link
2074      * function ourselves. */
2075     result = GST_PAD_LINKFUNC (sinkpad) (sinkpad, srcpad);
2076   } else {
2077     result = GST_PAD_LINK_OK;
2078   }
2079
2080   GST_OBJECT_LOCK (srcpad);
2081   GST_OBJECT_LOCK (sinkpad);
2082
2083   if (result == GST_PAD_LINK_OK) {
2084     GST_OBJECT_UNLOCK (sinkpad);
2085     GST_OBJECT_UNLOCK (srcpad);
2086
2087     /* fire off a signal to each of the pads telling them
2088      * that they've been linked */
2089     g_signal_emit (srcpad, gst_pad_signals[PAD_LINKED], 0, sinkpad);
2090     g_signal_emit (sinkpad, gst_pad_signals[PAD_LINKED], 0, srcpad);
2091
2092     GST_CAT_INFO (GST_CAT_PADS, "linked %s:%s and %s:%s, successful",
2093         GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2094   } else {
2095     GST_CAT_INFO (GST_CAT_PADS, "link between %s:%s and %s:%s failed",
2096         GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2097
2098     GST_PAD_PEER (srcpad) = NULL;
2099     GST_PAD_PEER (sinkpad) = NULL;
2100
2101     GST_OBJECT_UNLOCK (sinkpad);
2102     GST_OBJECT_UNLOCK (srcpad);
2103   }
2104
2105 done:
2106   if (parent) {
2107     gst_element_post_message (parent,
2108         gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2109             GST_STRUCTURE_CHANGE_TYPE_PAD_LINK, parent, FALSE));
2110     gst_object_unref (parent);
2111   }
2112
2113   return result;
2114 }
2115
2116 /**
2117  * gst_pad_link:
2118  * @srcpad: the source #GstPad to link.
2119  * @sinkpad: the sink #GstPad to link.
2120  *
2121  * Links the source pad and the sink pad.
2122  *
2123  * Returns: A result code indicating if the connection worked or
2124  *          what went wrong.
2125  *
2126  * MT Safe.
2127  */
2128 GstPadLinkReturn
2129 gst_pad_link (GstPad * srcpad, GstPad * sinkpad)
2130 {
2131   return gst_pad_link_full (srcpad, sinkpad, GST_PAD_LINK_CHECK_DEFAULT);
2132 }
2133
2134 static void
2135 gst_pad_set_pad_template (GstPad * pad, GstPadTemplate * templ)
2136 {
2137   GstPadTemplate **template_p;
2138
2139   /* this function would need checks if it weren't static */
2140
2141   GST_OBJECT_LOCK (pad);
2142   template_p = &pad->padtemplate;
2143   gst_object_replace ((GstObject **) template_p, (GstObject *) templ);
2144   GST_OBJECT_UNLOCK (pad);
2145
2146   if (templ)
2147     gst_pad_template_pad_created (templ, pad);
2148 }
2149
2150 /**
2151  * gst_pad_get_pad_template:
2152  * @pad: a #GstPad.
2153  *
2154  * Gets the template for @pad.
2155  *
2156  * Returns: the #GstPadTemplate from which this pad was instantiated, or %NULL
2157  * if this pad has no template.
2158  *
2159  * FIXME: currently returns an unrefcounted padtemplate.
2160  */
2161 GstPadTemplate *
2162 gst_pad_get_pad_template (GstPad * pad)
2163 {
2164   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2165
2166   return GST_PAD_PAD_TEMPLATE (pad);
2167 }
2168
2169
2170 /* should be called with the pad LOCK held */
2171 /* refs the caps, so caller is responsible for getting it unreffed */
2172 static GstCaps *
2173 gst_pad_get_caps_unlocked (GstPad * pad)
2174 {
2175   GstCaps *result = NULL;
2176   GstPadTemplate *templ;
2177
2178   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "get pad caps");
2179
2180   if (GST_PAD_GETCAPSFUNC (pad)) {
2181     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2182         "dispatching to pad getcaps function");
2183
2184     GST_OBJECT_FLAG_SET (pad, GST_PAD_IN_GETCAPS);
2185     GST_OBJECT_UNLOCK (pad);
2186     result = GST_PAD_GETCAPSFUNC (pad) (pad);
2187     GST_OBJECT_LOCK (pad);
2188     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_IN_GETCAPS);
2189
2190     if (result == NULL) {
2191       g_critical ("pad %s:%s returned NULL caps from getcaps function",
2192           GST_DEBUG_PAD_NAME (pad));
2193     } else {
2194       GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2195           "pad getcaps returned %" GST_PTR_FORMAT, result);
2196 #ifndef G_DISABLE_ASSERT
2197       /* check that the returned caps are a real subset of the template caps */
2198       if (GST_PAD_PAD_TEMPLATE (pad)) {
2199         const GstCaps *templ_caps =
2200             GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (pad));
2201         if (!gst_caps_is_subset (result, templ_caps)) {
2202           GstCaps *temp;
2203
2204           GST_CAT_ERROR_OBJECT (GST_CAT_CAPS, pad,
2205               "pad returned caps %" GST_PTR_FORMAT
2206               " which are not a real subset of its template caps %"
2207               GST_PTR_FORMAT, result, templ_caps);
2208           g_warning
2209               ("pad %s:%s returned caps which are not a real "
2210               "subset of its template caps", GST_DEBUG_PAD_NAME (pad));
2211           temp = gst_caps_intersect (templ_caps, result);
2212           gst_caps_unref (result);
2213           result = temp;
2214         }
2215       }
2216 #endif
2217       goto done;
2218     }
2219   }
2220   if ((templ = GST_PAD_PAD_TEMPLATE (pad))) {
2221     result = GST_PAD_TEMPLATE_CAPS (templ);
2222     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2223         "using pad template %p with caps %p %" GST_PTR_FORMAT, templ, result,
2224         result);
2225
2226     result = gst_caps_ref (result);
2227     goto done;
2228   }
2229   if ((result = GST_PAD_CAPS (pad))) {
2230     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2231         "using pad caps %p %" GST_PTR_FORMAT, result, result);
2232
2233     result = gst_caps_ref (result);
2234     goto done;
2235   }
2236
2237   /* this almost never happens */
2238   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "pad has no caps");
2239   result = gst_caps_new_empty ();
2240
2241 done:
2242   return result;
2243 }
2244
2245 /* FIXME-0.11: what about making this the default and using
2246  * gst_caps_make_writable() explicitely where needed
2247  */
2248 /**
2249  * gst_pad_get_caps_reffed:
2250  * @pad: a  #GstPad to get the capabilities of.
2251  *
2252  * Gets the capabilities this pad can produce or consume. Preferred function if
2253  * one only wants to read or intersect the caps.
2254  *
2255  * Returns: the caps of the pad with incremented ref-count.
2256  *
2257  * Since: 0.10.26
2258  */
2259 GstCaps *
2260 gst_pad_get_caps_reffed (GstPad * pad)
2261 {
2262   GstCaps *result = NULL;
2263
2264   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2265
2266   GST_OBJECT_LOCK (pad);
2267
2268   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "get pad caps");
2269
2270   result = gst_pad_get_caps_unlocked (pad);
2271
2272   GST_OBJECT_UNLOCK (pad);
2273
2274   return result;
2275 }
2276
2277 /**
2278  * gst_pad_get_caps:
2279  * @pad: a  #GstPad to get the capabilities of.
2280  *
2281  * Gets the capabilities this pad can produce or consume.
2282  * Note that this method doesn't necessarily return the caps set by
2283  * gst_pad_set_caps() - use GST_PAD_CAPS() for that instead.
2284  * gst_pad_get_caps returns all possible caps a pad can operate with, using
2285  * the pad's get_caps function;
2286  * this returns the pad template caps if not explicitly set.
2287  *
2288  * Returns: a newly allocated copy of the #GstCaps of this pad.
2289  *
2290  * MT safe.
2291  */
2292 GstCaps *
2293 gst_pad_get_caps (GstPad * pad)
2294 {
2295   GstCaps *result = gst_pad_get_caps_reffed (pad);
2296
2297   /* be sure that we have a copy */
2298   if (G_LIKELY (result))
2299     result = gst_caps_make_writable (result);
2300
2301   return result;
2302 }
2303
2304 /* FIXME-0.11: what about making this the default and using
2305  * gst_caps_make_writable() explicitely where needed
2306  */
2307 /**
2308  * gst_pad_peer_get_caps_reffed:
2309  * @pad: a  #GstPad to get the capabilities of.
2310  *
2311  * Gets the capabilities of the peer connected to this pad. Preferred function
2312  * if one only wants to read or intersect the caps.
2313  *
2314  * Returns: the caps of the pad with incremented ref-count.
2315  *
2316  * Since: 0.10.26
2317  */
2318 GstCaps *
2319 gst_pad_peer_get_caps_reffed (GstPad * pad)
2320 {
2321   GstPad *peerpad;
2322   GstCaps *result = NULL;
2323
2324   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2325
2326   GST_OBJECT_LOCK (pad);
2327
2328   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "get peer caps");
2329
2330   peerpad = GST_PAD_PEER (pad);
2331   if (G_UNLIKELY (peerpad == NULL))
2332     goto no_peer;
2333
2334   gst_object_ref (peerpad);
2335   GST_OBJECT_UNLOCK (pad);
2336
2337   result = gst_pad_get_caps_reffed (peerpad);
2338
2339   gst_object_unref (peerpad);
2340
2341   return result;
2342
2343 no_peer:
2344   {
2345     GST_OBJECT_UNLOCK (pad);
2346     return NULL;
2347   }
2348 }
2349
2350 /**
2351  * gst_pad_peer_get_caps:
2352  * @pad: a  #GstPad to get the peer capabilities of.
2353  *
2354  * Gets the capabilities of the peer connected to this pad. Similar to
2355  * gst_pad_get_caps().
2356  *
2357  * Returns: a newly allocated copy of the #GstCaps of the peer pad. Use
2358  * gst_caps_unref() to get rid of it. This function returns %NULL if there is
2359  * no peer pad.
2360  */
2361 GstCaps *
2362 gst_pad_peer_get_caps (GstPad * pad)
2363 {
2364   GstPad *peerpad;
2365   GstCaps *result = NULL;
2366
2367   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2368
2369   GST_OBJECT_LOCK (pad);
2370
2371   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "get peer caps");
2372
2373   peerpad = GST_PAD_PEER (pad);
2374   if (G_UNLIKELY (peerpad == NULL))
2375     goto no_peer;
2376
2377   gst_object_ref (peerpad);
2378   GST_OBJECT_UNLOCK (pad);
2379
2380   result = gst_pad_get_caps (peerpad);
2381
2382   gst_object_unref (peerpad);
2383
2384   return result;
2385
2386 no_peer:
2387   {
2388     GST_OBJECT_UNLOCK (pad);
2389     return NULL;
2390   }
2391 }
2392
2393 static gboolean
2394 fixate_value (GValue * dest, const GValue * src)
2395 {
2396   if (G_VALUE_TYPE (src) == GST_TYPE_INT_RANGE) {
2397     g_value_init (dest, G_TYPE_INT);
2398     g_value_set_int (dest, gst_value_get_int_range_min (src));
2399   } else if (G_VALUE_TYPE (src) == GST_TYPE_DOUBLE_RANGE) {
2400     g_value_init (dest, G_TYPE_DOUBLE);
2401     g_value_set_double (dest, gst_value_get_double_range_min (src));
2402   } else if (G_VALUE_TYPE (src) == GST_TYPE_FRACTION_RANGE) {
2403     gst_value_init_and_copy (dest, gst_value_get_fraction_range_min (src));
2404   } else if (G_VALUE_TYPE (src) == GST_TYPE_LIST) {
2405     GValue temp = { 0 };
2406
2407     /* list could be empty */
2408     if (gst_value_list_get_size (src) <= 0)
2409       return FALSE;
2410
2411     gst_value_init_and_copy (&temp, gst_value_list_get_value (src, 0));
2412
2413     if (!fixate_value (dest, &temp))
2414       gst_value_init_and_copy (dest, &temp);
2415     g_value_unset (&temp);
2416   } else if (G_VALUE_TYPE (src) == GST_TYPE_ARRAY) {
2417     gboolean res = FALSE;
2418     guint n, len;
2419
2420     len = gst_value_array_get_size (src);
2421     g_value_init (dest, GST_TYPE_ARRAY);
2422     for (n = 0; n < len; n++) {
2423       GValue kid = { 0 };
2424       const GValue *orig_kid = gst_value_array_get_value (src, n);
2425
2426       if (!fixate_value (&kid, orig_kid))
2427         gst_value_init_and_copy (&kid, orig_kid);
2428       else
2429         res = TRUE;
2430       gst_value_array_append_value (dest, &kid);
2431       g_value_unset (&kid);
2432     }
2433
2434     if (!res)
2435       g_value_unset (dest);
2436
2437     return res;
2438   } else {
2439     return FALSE;
2440   }
2441
2442   return TRUE;
2443 }
2444
2445 static gboolean
2446 gst_pad_default_fixate (GQuark field_id, const GValue * value, gpointer data)
2447 {
2448   GstStructure *s = data;
2449   GValue v = { 0 };
2450
2451   if (fixate_value (&v, value)) {
2452     gst_structure_id_set_value (s, field_id, &v);
2453     g_value_unset (&v);
2454   }
2455
2456   return TRUE;
2457 }
2458
2459 /**
2460  * gst_pad_fixate_caps:
2461  * @pad: a  #GstPad to fixate
2462  * @caps: the  #GstCaps to fixate
2463  *
2464  * Fixate a caps on the given pad. Modifies the caps in place, so you should
2465  * make sure that the caps are actually writable (see gst_caps_make_writable()).
2466  */
2467 void
2468 gst_pad_fixate_caps (GstPad * pad, GstCaps * caps)
2469 {
2470   GstPadFixateCapsFunction fixatefunc;
2471   GstStructure *s;
2472
2473   g_return_if_fail (GST_IS_PAD (pad));
2474   g_return_if_fail (caps != NULL);
2475   g_return_if_fail (!gst_caps_is_empty (caps));
2476   /* FIXME-0.11: do not allow fixating any-caps
2477    * g_return_if_fail (!gst_caps_is_any (caps));
2478    */
2479
2480   if (gst_caps_is_fixed (caps) || gst_caps_is_any (caps))
2481     return;
2482
2483   fixatefunc = GST_PAD_FIXATECAPSFUNC (pad);
2484   if (fixatefunc) {
2485     fixatefunc (pad, caps);
2486   }
2487
2488   /* default fixation */
2489   gst_caps_truncate (caps);
2490   s = gst_caps_get_structure (caps, 0);
2491   gst_structure_foreach (s, gst_pad_default_fixate, s);
2492 }
2493
2494 /* Default accept caps implementation just checks against
2495  * against the allowed caps for the pad */
2496 static gboolean
2497 gst_pad_acceptcaps_default (GstPad * pad, GstCaps * caps)
2498 {
2499   /* get the caps and see if it intersects to something not empty */
2500   GstCaps *allowed;
2501   gboolean result = FALSE;
2502
2503   GST_DEBUG_OBJECT (pad, "caps %" GST_PTR_FORMAT, caps);
2504
2505   allowed = gst_pad_get_caps_reffed (pad);
2506   if (!allowed)
2507     goto nothing_allowed;
2508
2509   GST_DEBUG_OBJECT (pad, "allowed caps %" GST_PTR_FORMAT, allowed);
2510
2511   result = gst_caps_can_intersect (allowed, caps);
2512
2513   gst_caps_unref (allowed);
2514
2515   return result;
2516
2517   /* ERRORS */
2518 nothing_allowed:
2519   {
2520     GST_DEBUG_OBJECT (pad, "no caps allowed on the pad");
2521     return FALSE;
2522   }
2523 }
2524
2525 /**
2526  * gst_pad_accept_caps:
2527  * @pad: a #GstPad to check
2528  * @caps: a #GstCaps to check on the pad
2529  *
2530  * Check if the given pad accepts the caps.
2531  *
2532  * Returns: TRUE if the pad can accept the caps.
2533  */
2534 gboolean
2535 gst_pad_accept_caps (GstPad * pad, GstCaps * caps)
2536 {
2537   gboolean result;
2538   GstPadAcceptCapsFunction acceptfunc;
2539   GstCaps *existing = NULL;
2540
2541   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2542
2543   /* any pad can be unnegotiated */
2544   if (caps == NULL)
2545     return TRUE;
2546
2547   /* lock for checking the existing caps */
2548   GST_OBJECT_LOCK (pad);
2549   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "accept caps of %p", caps);
2550   /* The current caps on a pad are trivially acceptable */
2551   if (G_LIKELY ((existing = GST_PAD_CAPS (pad)))) {
2552     if (caps == existing || gst_caps_is_equal (caps, existing))
2553       goto is_same_caps;
2554   }
2555   acceptfunc = GST_PAD_ACCEPTCAPSFUNC (pad);
2556   GST_OBJECT_UNLOCK (pad);
2557
2558   if (G_LIKELY (acceptfunc)) {
2559     /* we can call the function */
2560     result = acceptfunc (pad, caps);
2561     GST_DEBUG_OBJECT (pad, "acceptfunc returned %d", result);
2562   } else {
2563     /* Only null if the element explicitly unset it */
2564     result = gst_pad_acceptcaps_default (pad, caps);
2565     GST_DEBUG_OBJECT (pad, "default acceptcaps returned %d", result);
2566   }
2567   return result;
2568
2569 is_same_caps:
2570   {
2571     GST_DEBUG_OBJECT (pad, "pad had same caps");
2572     GST_OBJECT_UNLOCK (pad);
2573     return TRUE;
2574   }
2575 }
2576
2577 /**
2578  * gst_pad_peer_accept_caps:
2579  * @pad: a  #GstPad to check the peer of
2580  * @caps: a #GstCaps to check on the pad
2581  *
2582  * Check if the peer of @pad accepts @caps. If @pad has no peer, this function
2583  * returns TRUE.
2584  *
2585  * Returns: TRUE if the peer of @pad can accept the caps or @pad has no peer.
2586  */
2587 gboolean
2588 gst_pad_peer_accept_caps (GstPad * pad, GstCaps * caps)
2589 {
2590   GstPad *peerpad;
2591   gboolean result;
2592
2593   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2594
2595   GST_OBJECT_LOCK (pad);
2596
2597   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "peer accept caps of (%p)", pad);
2598
2599   peerpad = GST_PAD_PEER (pad);
2600   if (G_UNLIKELY (peerpad == NULL))
2601     goto no_peer;
2602
2603   gst_object_ref (peerpad);
2604   /* release lock before calling external methods but keep ref to pad */
2605   GST_OBJECT_UNLOCK (pad);
2606
2607   result = gst_pad_accept_caps (peerpad, caps);
2608
2609   gst_object_unref (peerpad);
2610
2611   return result;
2612
2613 no_peer:
2614   {
2615     GST_OBJECT_UNLOCK (pad);
2616     return TRUE;
2617   }
2618 }
2619
2620 /**
2621  * gst_pad_set_caps:
2622  * @pad: a  #GstPad to set the capabilities of.
2623  * @caps: a #GstCaps to set.
2624  *
2625  * Sets the capabilities of this pad. The caps must be fixed. Any previous
2626  * caps on the pad will be unreffed. This function refs the caps so you should
2627  * unref if as soon as you don't need it anymore.
2628  * It is possible to set NULL caps, which will make the pad unnegotiated
2629  * again.
2630  *
2631  * Returns: TRUE if the caps could be set. FALSE if the caps were not fixed
2632  * or bad parameters were provided to this function.
2633  *
2634  * MT safe.
2635  */
2636 gboolean
2637 gst_pad_set_caps (GstPad * pad, GstCaps * caps)
2638 {
2639   GstPadSetCapsFunction setcaps;
2640   GstCaps *existing;
2641
2642   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2643   g_return_val_if_fail (caps == NULL || gst_caps_is_fixed (caps), FALSE);
2644
2645   GST_OBJECT_LOCK (pad);
2646   existing = GST_PAD_CAPS (pad);
2647   if (existing == caps)
2648     goto was_ok;
2649
2650   if (gst_caps_is_equal (caps, existing))
2651     goto setting_same_caps;
2652
2653   setcaps = GST_PAD_SETCAPSFUNC (pad);
2654
2655   /* call setcaps function to configure the pad only if the
2656    * caps is not NULL */
2657   if (setcaps != NULL && caps) {
2658     if (!GST_PAD_IS_IN_SETCAPS (pad)) {
2659       GST_OBJECT_FLAG_SET (pad, GST_PAD_IN_SETCAPS);
2660       GST_OBJECT_UNLOCK (pad);
2661       if (!setcaps (pad, caps))
2662         goto could_not_set;
2663       GST_OBJECT_LOCK (pad);
2664       GST_OBJECT_FLAG_UNSET (pad, GST_PAD_IN_SETCAPS);
2665     } else {
2666       GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "pad was dispatching");
2667     }
2668   }
2669
2670   gst_caps_replace (&GST_PAD_CAPS (pad), caps);
2671   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "caps %p %" GST_PTR_FORMAT, caps,
2672       caps);
2673   GST_OBJECT_UNLOCK (pad);
2674
2675   g_object_notify (G_OBJECT (pad), "caps");
2676
2677   return TRUE;
2678
2679 was_ok:
2680   {
2681     GST_OBJECT_UNLOCK (pad);
2682     return TRUE;
2683   }
2684 setting_same_caps:
2685   {
2686     gst_caps_replace (&GST_PAD_CAPS (pad), caps);
2687     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2688         "caps %p %" GST_PTR_FORMAT " same as existing, updating ptr only", caps,
2689         caps);
2690     GST_OBJECT_UNLOCK (pad);
2691     return TRUE;
2692   }
2693
2694   /* ERRORS */
2695 could_not_set:
2696   {
2697     GST_OBJECT_LOCK (pad);
2698     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_IN_SETCAPS);
2699     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2700         "caps %" GST_PTR_FORMAT " could not be set", caps);
2701     GST_OBJECT_UNLOCK (pad);
2702
2703     return FALSE;
2704   }
2705 }
2706
2707 static gboolean
2708 gst_pad_configure_sink (GstPad * pad, GstCaps * caps)
2709 {
2710   gboolean res;
2711
2712   /* See if pad accepts the caps */
2713   if (!gst_caps_can_intersect (caps, gst_pad_get_pad_template_caps (pad)))
2714     goto not_accepted;
2715
2716   /* set caps on pad if call succeeds */
2717   res = gst_pad_set_caps (pad, caps);
2718   /* no need to unref the caps here, set_caps takes a ref and
2719    * our ref goes away when we leave this function. */
2720
2721   return res;
2722
2723 not_accepted:
2724   {
2725     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2726         "caps %" GST_PTR_FORMAT " not accepted", caps);
2727     return FALSE;
2728   }
2729 }
2730
2731 /* returns TRUE if the src pad could be configured to accept the given caps */
2732 static gboolean
2733 gst_pad_configure_src (GstPad * pad, GstCaps * caps, gboolean dosetcaps)
2734 {
2735   gboolean res;
2736
2737   if (dosetcaps) {
2738     /* See if pad accepts the caps */
2739     if (!gst_pad_accept_caps (pad, caps))
2740       goto not_accepted;
2741
2742     res = gst_pad_set_caps (pad, caps);
2743   } else {
2744     res = TRUE;
2745   }
2746   return res;
2747
2748 not_accepted:
2749   {
2750     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2751         "caps %" GST_PTR_FORMAT " not accepted", caps);
2752     return FALSE;
2753   }
2754 }
2755
2756 /**
2757  * gst_pad_get_pad_template_caps:
2758  * @pad: a #GstPad to get the template capabilities from.
2759  *
2760  * Gets the capabilities for @pad's template.
2761  *
2762  * Returns: the #GstCaps of this pad template. If you intend to keep a
2763  * reference on the caps, make a copy (see gst_caps_copy ()).
2764  */
2765 const GstCaps *
2766 gst_pad_get_pad_template_caps (GstPad * pad)
2767 {
2768   static GstStaticCaps anycaps = GST_STATIC_CAPS ("ANY");
2769
2770   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2771
2772   if (GST_PAD_PAD_TEMPLATE (pad))
2773     return GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (pad));
2774
2775   return gst_static_caps_get (&anycaps);
2776 }
2777
2778 /**
2779  * gst_pad_get_peer:
2780  * @pad: a #GstPad to get the peer of.
2781  *
2782  * Gets the peer of @pad. This function refs the peer pad so
2783  * you need to unref it after use.
2784  *
2785  * Returns: the peer #GstPad. Unref after usage.
2786  *
2787  * MT safe.
2788  */
2789 GstPad *
2790 gst_pad_get_peer (GstPad * pad)
2791 {
2792   GstPad *result;
2793
2794   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2795
2796   GST_OBJECT_LOCK (pad);
2797   result = GST_PAD_PEER (pad);
2798   if (result)
2799     gst_object_ref (result);
2800   GST_OBJECT_UNLOCK (pad);
2801
2802   return result;
2803 }
2804
2805 /**
2806  * gst_pad_get_allowed_caps:
2807  * @pad: a #GstPad.
2808  *
2809  * Gets the capabilities of the allowed media types that can flow through
2810  * @pad and its peer.
2811  *
2812  * The allowed capabilities is calculated as the intersection of the results of
2813  * calling gst_pad_get_caps() on @pad and its peer. The caller owns a reference
2814  * on the resulting caps.
2815  *
2816  * Returns: the allowed #GstCaps of the pad link. Unref the caps when you no
2817  * longer need it. This function returns NULL when @pad has no peer.
2818  *
2819  * MT safe.
2820  */
2821 GstCaps *
2822 gst_pad_get_allowed_caps (GstPad * pad)
2823 {
2824   GstCaps *mycaps;
2825   GstCaps *caps;
2826   GstCaps *peercaps;
2827   GstPad *peer;
2828
2829   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2830
2831   GST_OBJECT_LOCK (pad);
2832
2833   peer = GST_PAD_PEER (pad);
2834   if (G_UNLIKELY (peer == NULL))
2835     goto no_peer;
2836
2837   GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "getting allowed caps");
2838
2839   gst_object_ref (peer);
2840   GST_OBJECT_UNLOCK (pad);
2841   mycaps = gst_pad_get_caps_reffed (pad);
2842
2843   peercaps = gst_pad_get_caps_reffed (peer);
2844   gst_object_unref (peer);
2845
2846   caps = gst_caps_intersect (mycaps, peercaps);
2847   gst_caps_unref (peercaps);
2848   gst_caps_unref (mycaps);
2849
2850   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "allowed caps %" GST_PTR_FORMAT,
2851       caps);
2852
2853   return caps;
2854
2855 no_peer:
2856   {
2857     GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "no peer");
2858     GST_OBJECT_UNLOCK (pad);
2859
2860     return NULL;
2861   }
2862 }
2863
2864 /**
2865  * gst_pad_get_negotiated_caps:
2866  * @pad: a #GstPad.
2867  *
2868  * Gets the capabilities of the media type that currently flows through @pad
2869  * and its peer.
2870  *
2871  * This function can be used on both src and sinkpads. Note that srcpads are
2872  * always negotiated before sinkpads so it is possible that the negotiated caps
2873  * on the srcpad do not match the negotiated caps of the peer.
2874  *
2875  * Returns: the negotiated #GstCaps of the pad link.  Unref the caps when
2876  * you no longer need it. This function returns NULL when the @pad has no
2877  * peer or is not negotiated yet.
2878  *
2879  * MT safe.
2880  */
2881 GstCaps *
2882 gst_pad_get_negotiated_caps (GstPad * pad)
2883 {
2884   GstCaps *caps;
2885   GstPad *peer;
2886
2887   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2888
2889   GST_OBJECT_LOCK (pad);
2890
2891   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
2892     goto no_peer;
2893
2894   GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "getting negotiated caps");
2895
2896   caps = GST_PAD_CAPS (pad);
2897   if (caps)
2898     gst_caps_ref (caps);
2899   GST_OBJECT_UNLOCK (pad);
2900
2901   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "negotiated caps %" GST_PTR_FORMAT,
2902       caps);
2903
2904   return caps;
2905
2906 no_peer:
2907   {
2908     GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "no peer");
2909     GST_OBJECT_UNLOCK (pad);
2910
2911     return NULL;
2912   }
2913 }
2914
2915 /* calls the buffer_alloc function on the given pad */
2916 static GstFlowReturn
2917 gst_pad_buffer_alloc_unchecked (GstPad * pad, guint64 offset, gint size,
2918     GstCaps * caps, GstBuffer ** buf)
2919 {
2920   GstFlowReturn ret;
2921   GstPadBufferAllocFunction bufferallocfunc;
2922
2923   GST_OBJECT_LOCK (pad);
2924   /* when the pad is flushing we cannot give a buffer */
2925   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
2926     goto flushing;
2927
2928   bufferallocfunc = pad->bufferallocfunc;
2929
2930   if (offset == GST_BUFFER_OFFSET_NONE) {
2931     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
2932         "calling bufferallocfunc &%s (@%p) for size %d offset NONE",
2933         GST_DEBUG_FUNCPTR_NAME (bufferallocfunc), bufferallocfunc, size);
2934   } else {
2935     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
2936         "calling bufferallocfunc &%s (@%p) of for size %d offset %"
2937         G_GUINT64_FORMAT, GST_DEBUG_FUNCPTR_NAME (bufferallocfunc),
2938         bufferallocfunc, size, offset);
2939   }
2940   GST_OBJECT_UNLOCK (pad);
2941
2942   /* G_LIKELY for now since most elements don't implement a buffer alloc
2943    * function and there is no default alloc proxy function as this is usually
2944    * not possible. */
2945   if (G_LIKELY (bufferallocfunc == NULL))
2946     goto fallback;
2947
2948   ret = bufferallocfunc (pad, offset, size, caps, buf);
2949
2950   if (G_UNLIKELY (ret != GST_FLOW_OK))
2951     goto error;
2952
2953   /* no error, but NULL buffer means fallback to the default */
2954   if (G_UNLIKELY (*buf == NULL))
2955     goto fallback;
2956
2957   /* If the buffer alloc function didn't set up the caps like it should,
2958    * do it for it */
2959   if (G_UNLIKELY (caps && (GST_BUFFER_CAPS (*buf) == NULL))) {
2960     GST_WARNING_OBJECT (pad,
2961         "Buffer allocation function did not set caps. Setting");
2962     gst_buffer_set_caps (*buf, caps);
2963   }
2964   return ret;
2965
2966 flushing:
2967   {
2968     /* pad was flushing */
2969     GST_OBJECT_UNLOCK (pad);
2970     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "pad was flushing");
2971     return GST_FLOW_WRONG_STATE;
2972   }
2973 error:
2974   {
2975     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
2976         "alloc function returned error (%d) %s", ret, gst_flow_get_name (ret));
2977     return ret;
2978   }
2979 fallback:
2980   {
2981     /* fallback case, allocate a buffer of our own, add pad caps. */
2982     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "fallback buffer alloc");
2983
2984     if ((*buf = gst_buffer_try_new_and_alloc (size))) {
2985       GST_BUFFER_OFFSET (*buf) = offset;
2986       gst_buffer_set_caps (*buf, caps);
2987       return GST_FLOW_OK;
2988     } else {
2989       GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
2990           "out of memory allocating %d bytes", size);
2991       return GST_FLOW_ERROR;
2992     }
2993   }
2994 }
2995
2996 /* FIXME 0.11: size should be unsigned */
2997 static GstFlowReturn
2998 gst_pad_alloc_buffer_full (GstPad * pad, guint64 offset, gint size,
2999     GstCaps * caps, GstBuffer ** buf, gboolean setcaps)
3000 {
3001   GstPad *peer;
3002   GstFlowReturn ret;
3003   GstCaps *newcaps;
3004   gboolean caps_changed;
3005
3006   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
3007   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
3008   g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
3009   g_return_val_if_fail (size >= 0, GST_FLOW_ERROR);
3010
3011   GST_DEBUG_OBJECT (pad, "offset %" G_GUINT64_FORMAT ", size %d, caps %"
3012       GST_PTR_FORMAT, offset, size, caps);
3013
3014   GST_OBJECT_LOCK (pad);
3015   while (G_UNLIKELY (GST_PAD_IS_BLOCKED (pad)))
3016     if ((ret = handle_pad_block (pad)) != GST_FLOW_OK)
3017       goto flushed;
3018
3019   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
3020     goto no_peer;
3021
3022   gst_object_ref (peer);
3023   GST_OBJECT_UNLOCK (pad);
3024
3025   ret = gst_pad_buffer_alloc_unchecked (peer, offset, size, caps, buf);
3026   gst_object_unref (peer);
3027
3028   if (G_UNLIKELY (ret != GST_FLOW_OK))
3029     goto peer_error;
3030
3031   /* FIXME, move capnego this into a base class? */
3032   newcaps = GST_BUFFER_CAPS (*buf);
3033
3034   /* Lock for checking caps, pretty pointless as the _pad_push() function might
3035    * change it concurrently, one of the problems with automatic caps setting in
3036    * pad_alloc_and_set_caps. Worst case, if does a check too much, but only
3037    * when there is heavy renegotiation going on in both directions. */
3038   GST_OBJECT_LOCK (pad);
3039   caps_changed = newcaps && newcaps != GST_PAD_CAPS (pad);
3040   GST_OBJECT_UNLOCK (pad);
3041
3042   /* we got a new datatype on the pad, see if it can handle it */
3043   if (G_UNLIKELY (caps_changed)) {
3044     GST_DEBUG_OBJECT (pad,
3045         "caps changed from %" GST_PTR_FORMAT " to %p %" GST_PTR_FORMAT,
3046         GST_PAD_CAPS (pad), newcaps, newcaps);
3047     if (G_UNLIKELY (!gst_pad_configure_src (pad, newcaps, setcaps)))
3048       goto not_negotiated;
3049   }
3050
3051   /* sanity check (only if caps are the same) */
3052   if (G_LIKELY (newcaps == caps) && G_UNLIKELY (GST_BUFFER_SIZE (*buf) < size))
3053     goto wrong_size_fallback;
3054
3055   return ret;
3056
3057 flushed:
3058   {
3059     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "pad block stopped by flush");
3060     GST_OBJECT_UNLOCK (pad);
3061     return ret;
3062   }
3063 no_peer:
3064   {
3065     /* pad has no peer */
3066     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
3067         "called bufferallocfunc but had no peer");
3068     GST_OBJECT_UNLOCK (pad);
3069     return GST_FLOW_NOT_LINKED;
3070   }
3071 peer_error:
3072   {
3073     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3074         "alloc function returned error %s", gst_flow_get_name (ret));
3075     return ret;
3076   }
3077 not_negotiated:
3078   {
3079     gst_buffer_unref (*buf);
3080     *buf = NULL;
3081     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3082         "alloc function returned unacceptable buffer");
3083     return GST_FLOW_NOT_NEGOTIATED;
3084   }
3085 wrong_size_fallback:
3086   {
3087     GST_CAT_ERROR_OBJECT (GST_CAT_PADS, pad, "buffer returned by alloc "
3088         "function is too small (%u < %d), doing fallback buffer alloc",
3089         GST_BUFFER_SIZE (*buf), size);
3090
3091     gst_buffer_unref (*buf);
3092
3093     if ((*buf = gst_buffer_try_new_and_alloc (size))) {
3094       GST_BUFFER_OFFSET (*buf) = offset;
3095       gst_buffer_set_caps (*buf, caps);
3096       return GST_FLOW_OK;
3097     } else {
3098       GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
3099           "out of memory allocating %d bytes", size);
3100       return GST_FLOW_ERROR;
3101     }
3102   }
3103 }
3104
3105 /**
3106  * gst_pad_alloc_buffer:
3107  * @pad: a source #GstPad
3108  * @offset: the offset of the new buffer in the stream
3109  * @size: the size of the new buffer
3110  * @caps: the caps of the new buffer
3111  * @buf: a newly allocated buffer
3112  *
3113  * Allocates a new, empty buffer optimized to push to pad @pad.  This
3114  * function only works if @pad is a source pad and has a peer.
3115  *
3116  * A new, empty #GstBuffer will be put in the @buf argument.
3117  * You need to check the caps of the buffer after performing this
3118  * function and renegotiate to the format if needed. If the caps changed, it is
3119  * possible that the buffer returned in @buf is not of the right size for the
3120  * new format, @buf needs to be unreffed and reallocated if this is the case.
3121  *
3122  * Returns: a result code indicating success of the operation. Any
3123  * result code other than #GST_FLOW_OK is an error and @buf should
3124  * not be used.
3125  * An error can occur if the pad is not connected or when the downstream
3126  * peer elements cannot provide an acceptable buffer.
3127  *
3128  * MT safe.
3129  */
3130
3131 /* FIXME 0.11: size should be unsigned */
3132 GstFlowReturn
3133 gst_pad_alloc_buffer (GstPad * pad, guint64 offset, gint size, GstCaps * caps,
3134     GstBuffer ** buf)
3135 {
3136   return gst_pad_alloc_buffer_full (pad, offset, size, caps, buf, FALSE);
3137 }
3138
3139 /**
3140  * gst_pad_alloc_buffer_and_set_caps:
3141  * @pad: a source #GstPad
3142  * @offset: the offset of the new buffer in the stream
3143  * @size: the size of the new buffer
3144  * @caps: the caps of the new buffer
3145  * @buf: a newly allocated buffer
3146  *
3147  * In addition to the function gst_pad_alloc_buffer(), this function
3148  * automatically calls gst_pad_set_caps() when the caps of the
3149  * newly allocated buffer are different from the @pad caps.
3150  *
3151  * After a renegotiation, the size of the new buffer returned in @buf could
3152  * be of the wrong size for the new format and must be unreffed an reallocated
3153  * in that case.
3154  *
3155  * Returns: a result code indicating success of the operation. Any
3156  * result code other than #GST_FLOW_OK is an error and @buf should
3157  * not be used.
3158  * An error can occur if the pad is not connected or when the downstream
3159  * peer elements cannot provide an acceptable buffer.
3160  *
3161  * MT safe.
3162  */
3163
3164 /* FIXME 0.11: size should be unsigned */
3165 GstFlowReturn
3166 gst_pad_alloc_buffer_and_set_caps (GstPad * pad, guint64 offset, gint size,
3167     GstCaps * caps, GstBuffer ** buf)
3168 {
3169   return gst_pad_alloc_buffer_full (pad, offset, size, caps, buf, TRUE);
3170 }
3171
3172
3173 #ifndef GST_REMOVE_DEPRECATED
3174 typedef struct
3175 {
3176   GList *list;
3177   guint32 cookie;
3178 } IntLinkIterData;
3179
3180 static void
3181 int_link_iter_data_free (IntLinkIterData * data)
3182 {
3183   g_list_free (data->list);
3184   g_slice_free (IntLinkIterData, data);
3185 }
3186 #endif
3187
3188 static GstIteratorItem
3189 iterate_pad (GstIterator * it, GstPad * pad)
3190 {
3191   gst_object_ref (pad);
3192   return GST_ITERATOR_ITEM_PASS;
3193 }
3194
3195 /**
3196  * gst_pad_iterate_internal_links_default:
3197  * @pad: the #GstPad to get the internal links of.
3198  *
3199  * Iterate the list of pads to which the given pad is linked to inside of
3200  * the parent element.
3201  * This is the default handler, and thus returns an iterator of all of the
3202  * pads inside the parent element with opposite direction.
3203  *
3204  * The caller must free this iterator after use with gst_iterator_free().
3205  *
3206  * Returns: a #GstIterator of #GstPad, or NULL if @pad has no parent. Unref each
3207  * returned pad with gst_object_unref().
3208  *
3209  * Since: 0.10.21
3210  */
3211 GstIterator *
3212 gst_pad_iterate_internal_links_default (GstPad * pad)
3213 {
3214   GstIterator *res;
3215   GList **padlist;
3216   guint32 *cookie;
3217   GMutex *lock;
3218   gpointer owner;
3219   GstIteratorDisposeFunction dispose;
3220
3221   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
3222
3223 #ifndef GST_REMOVE_DEPRECATED
3224   /* when we get here, the default handler for the iterate links is called,
3225    * which means that the user has not installed a custom one. We first check if
3226    * there is maybe a custom legacy function we can call. */
3227   if (GST_PAD_INTLINKFUNC (pad) &&
3228       GST_PAD_INTLINKFUNC (pad) != gst_pad_get_internal_links_default) {
3229     IntLinkIterData *data;
3230
3231     /* make an iterator for the list. We can't protect the list with a
3232      * cookie. If we would take the cookie of the parent element, we need to
3233      * have a parent, which is not required for GST_PAD_INTLINKFUNC(). We could
3234      * cache the per-pad list and invalidate the list when a new call to
3235      * INTLINKFUNC() returned a different list but then this would only work if
3236      * two concurrent iterators were used and the last iterator would still be
3237      * thread-unsafe. Just don't use this method anymore. */
3238     data = g_slice_new (IntLinkIterData);
3239     data->list = GST_PAD_INTLINKFUNC (pad) (pad);
3240     data->cookie = 0;
3241
3242     GST_WARNING_OBJECT (pad, "Making unsafe iterator");
3243
3244     cookie = &data->cookie;
3245     padlist = &data->list;
3246     owner = data;
3247     dispose = (GstIteratorDisposeFunction) int_link_iter_data_free;
3248     /* reuse the pad lock, it's all we have here */
3249     lock = GST_OBJECT_GET_LOCK (pad);
3250   } else
3251 #endif
3252   {
3253     GstElement *parent;
3254
3255     GST_OBJECT_LOCK (pad);
3256     parent = GST_PAD_PARENT (pad);
3257     if (!parent || !GST_IS_ELEMENT (parent))
3258       goto no_parent;
3259
3260     gst_object_ref (parent);
3261     GST_OBJECT_UNLOCK (pad);
3262
3263     if (pad->direction == GST_PAD_SRC)
3264       padlist = &parent->sinkpads;
3265     else
3266       padlist = &parent->srcpads;
3267
3268     GST_DEBUG_OBJECT (pad, "Making iterator");
3269
3270     cookie = &parent->pads_cookie;
3271     owner = parent;
3272     dispose = (GstIteratorDisposeFunction) gst_object_unref;
3273     lock = GST_OBJECT_GET_LOCK (parent);
3274   }
3275
3276   res = gst_iterator_new_list (GST_TYPE_PAD,
3277       lock, cookie, padlist, owner, (GstIteratorItemFunction) iterate_pad,
3278       dispose);
3279
3280   return res;
3281
3282   /* ERRORS */
3283 no_parent:
3284   {
3285     GST_OBJECT_UNLOCK (pad);
3286     GST_DEBUG_OBJECT (pad, "no parent element");
3287     return NULL;
3288   }
3289 }
3290
3291 /**
3292  * gst_pad_iterate_internal_links:
3293  * @pad: the GstPad to get the internal links of.
3294  *
3295  * Gets an iterator for the pads to which the given pad is linked to inside
3296  * of the parent element.
3297  *
3298  * Each #GstPad element yielded by the iterator will have its refcount increased,
3299  * so unref after use.
3300  *
3301  * Returns: a new #GstIterator of #GstPad or %NULL when the pad does not have an
3302  * iterator function configured. Use gst_iterator_free() after usage.
3303  *
3304  * Since: 0.10.21
3305  */
3306 GstIterator *
3307 gst_pad_iterate_internal_links (GstPad * pad)
3308 {
3309   GstIterator *res = NULL;
3310
3311   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
3312
3313   if (GST_PAD_ITERINTLINKFUNC (pad))
3314     res = GST_PAD_ITERINTLINKFUNC (pad) (pad);
3315
3316   return res;
3317 }
3318
3319 #ifndef GST_REMOVE_DEPRECATED
3320 static void
3321 add_unref_pad_to_list (GstPad * pad, GList ** list)
3322 {
3323   *list = g_list_prepend (*list, pad);
3324   gst_object_unref (pad);
3325 }
3326 #endif
3327
3328 /**
3329  * gst_pad_get_internal_links_default:
3330  * @pad: the #GstPad to get the internal links of.
3331  *
3332  * Gets a list of pads to which the given pad is linked to
3333  * inside of the parent element.
3334  * This is the default handler, and thus returns a list of all of the
3335  * pads inside the parent element with opposite direction.
3336  *
3337  * The caller must free this list after use with g_list_free().
3338  *
3339  * Returns: a newly allocated #GList of pads, or NULL if the pad has no parent.
3340  *
3341  * Not MT safe.
3342  *
3343  * Deprecated: This function does not ref the pads in the list so that they
3344  * could become invalid by the time the application accesses them. It's also
3345  * possible that the list changes while handling the pads, which the caller of
3346  * this function is unable to know. Use the thread-safe
3347  * gst_pad_iterate_internal_links_default() instead.
3348  */
3349 #ifndef GST_REMOVE_DEPRECATED
3350 GList *
3351 gst_pad_get_internal_links_default (GstPad * pad)
3352 {
3353   GList *res = NULL;
3354   GstElement *parent;
3355
3356   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
3357
3358   GST_WARNING_OBJECT (pad, "Unsafe internal links used");
3359
3360   /* when we get here, the default handler for get_internal_links is called,
3361    * which means that the user has not installed a custom one. We first check if
3362    * there is maybe a custom iterate function we can call. */
3363   if (GST_PAD_ITERINTLINKFUNC (pad) &&
3364       GST_PAD_ITERINTLINKFUNC (pad) != gst_pad_iterate_internal_links_default) {
3365     GstIterator *it;
3366     GstIteratorResult ires;
3367     gboolean done = FALSE;
3368
3369     it = gst_pad_iterate_internal_links (pad);
3370     /* loop over the iterator and put all elements into a list, we also
3371      * immediatly unref them, which is bad. */
3372     do {
3373       ires = gst_iterator_foreach (it, (GFunc) add_unref_pad_to_list, &res);
3374       switch (ires) {
3375         case GST_ITERATOR_OK:
3376         case GST_ITERATOR_DONE:
3377         case GST_ITERATOR_ERROR:
3378           done = TRUE;
3379           break;
3380         case GST_ITERATOR_RESYNC:
3381           /* restart, discard previous list */
3382           gst_iterator_resync (it);
3383           g_list_free (res);
3384           res = NULL;
3385           break;
3386       }
3387     } while (!done);
3388
3389     gst_iterator_free (it);
3390   } else {
3391     /* lock pad, check and ref parent */
3392     GST_OBJECT_LOCK (pad);
3393     parent = GST_PAD_PARENT (pad);
3394     if (!parent || !GST_IS_ELEMENT (parent))
3395       goto no_parent;
3396
3397     parent = gst_object_ref (parent);
3398     GST_OBJECT_UNLOCK (pad);
3399
3400     /* now lock the parent while we copy the pads */
3401     GST_OBJECT_LOCK (parent);
3402     if (pad->direction == GST_PAD_SRC)
3403       res = g_list_copy (parent->sinkpads);
3404     else
3405       res = g_list_copy (parent->srcpads);
3406     GST_OBJECT_UNLOCK (parent);
3407
3408     gst_object_unref (parent);
3409   }
3410
3411   /* At this point pads can be changed and unreffed. Nothing we can do about it
3412    * because for compatibility reasons this function cannot ref the pads or
3413    * notify the app that the list changed. */
3414
3415   return res;
3416
3417 no_parent:
3418   {
3419     GST_DEBUG_OBJECT (pad, "no parent");
3420     GST_OBJECT_UNLOCK (pad);
3421     return NULL;
3422   }
3423 }
3424 #endif /* GST_REMOVE_DEPRECATED */
3425
3426 /**
3427  * gst_pad_get_internal_links:
3428  * @pad: the #GstPad to get the internal links of.
3429  *
3430  * Gets a list of pads to which the given pad is linked to
3431  * inside of the parent element.
3432  * The caller must free this list after use.
3433  *
3434  * Not MT safe.
3435  *
3436  * Returns: a newly allocated #GList of pads, free with g_list_free().
3437  *
3438  * Deprecated: This function does not ref the pads in the list so that they
3439  * could become invalid by the time the application accesses them. It's also
3440  * possible that the list changes while handling the pads, which the caller of
3441  * this function is unable to know. Use the thread-safe
3442  * gst_pad_iterate_internal_links() instead.
3443  */
3444 #ifndef GST_REMOVE_DEPRECATED
3445 #ifdef GST_DISABLE_DEPRECATED
3446 GList *gst_pad_get_internal_links (GstPad * pad);
3447 #endif
3448 GList *
3449 gst_pad_get_internal_links (GstPad * pad)
3450 {
3451   GList *res = NULL;
3452
3453   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
3454
3455   GST_WARNING_OBJECT (pad, "Calling unsafe internal links");
3456
3457   if (GST_PAD_INTLINKFUNC (pad))
3458     res = GST_PAD_INTLINKFUNC (pad) (pad);
3459
3460   return res;
3461 }
3462 #endif /* GST_REMOVE_DEPRECATED */
3463
3464 static gboolean
3465 gst_pad_event_default_dispatch (GstPad * pad, GstEvent * event)
3466 {
3467   gboolean result = FALSE;
3468   GstIterator *iter;
3469   gboolean done = FALSE;
3470   gpointer item;
3471   GstPad *eventpad;
3472   GList *pushed_pads = NULL;
3473
3474   GST_INFO_OBJECT (pad, "Sending event %p (%s) to all internally linked pads",
3475       event, GST_EVENT_TYPE_NAME (event));
3476
3477   iter = gst_pad_iterate_internal_links (pad);
3478
3479   if (!iter)
3480     goto no_iter;
3481
3482   while (!done) {
3483     switch (gst_iterator_next (iter, &item)) {
3484       case GST_ITERATOR_OK:
3485         eventpad = GST_PAD_CAST (item);
3486
3487         /* if already pushed,  skip */
3488         if (g_list_find (pushed_pads, eventpad)) {
3489           gst_object_unref (item);
3490           break;
3491         }
3492
3493         if (GST_PAD_IS_SRC (eventpad)) {
3494           /* for each pad we send to, we should ref the event; it's up
3495            * to downstream to unref again when handled. */
3496           GST_LOG_OBJECT (pad, "Reffing and sending event %p (%s) to %s:%s",
3497               event, GST_EVENT_TYPE_NAME (event),
3498               GST_DEBUG_PAD_NAME (eventpad));
3499           gst_event_ref (event);
3500           result |= gst_pad_push_event (eventpad, event);
3501         } else {
3502           /* we only send the event on one pad, multi-sinkpad elements
3503            * should implement a handler */
3504           GST_LOG_OBJECT (pad, "sending event %p (%s) to one sink pad %s:%s",
3505               event, GST_EVENT_TYPE_NAME (event),
3506               GST_DEBUG_PAD_NAME (eventpad));
3507           result = gst_pad_push_event (eventpad, event);
3508           done = TRUE;
3509           event = NULL;
3510         }
3511
3512         pushed_pads = g_list_prepend (pushed_pads, eventpad);
3513
3514         gst_object_unref (item);
3515         break;
3516       case GST_ITERATOR_RESYNC:
3517         /* FIXME, if we want to reset the result value we need to remember which
3518          * pads pushed with which result */
3519         gst_iterator_resync (iter);
3520         break;
3521       case GST_ITERATOR_ERROR:
3522         GST_ERROR_OBJECT (pad, "Could not iterate over internally linked pads");
3523         done = TRUE;
3524         break;
3525       case GST_ITERATOR_DONE:
3526         done = TRUE;
3527         break;
3528     }
3529   }
3530   gst_iterator_free (iter);
3531
3532 no_iter:
3533
3534   /* If this is a sinkpad and we don't have pads to send the event to, we
3535    * return TRUE. This is so that when using the default handler on a sink
3536    * element, we don't fail to push it. */
3537   if (!pushed_pads)
3538     result = GST_PAD_IS_SINK (pad);
3539
3540   g_list_free (pushed_pads);
3541
3542   /* we handled the incoming event so we unref once */
3543   if (event) {
3544     GST_LOG_OBJECT (pad, "handled event %p, unreffing", event);
3545     gst_event_unref (event);
3546   }
3547
3548   return result;
3549 }
3550
3551 /**
3552  * gst_pad_event_default:
3553  * @pad: a #GstPad to call the default event handler on.
3554  * @event: the #GstEvent to handle.
3555  *
3556  * Invokes the default event handler for the given pad. End-of-stream and
3557  * discontinuity events are handled specially, and then the event is sent to all
3558  * pads internally linked to @pad. Note that if there are many possible sink
3559  * pads that are internally linked to @pad, only one will be sent an event.
3560  * Multi-sinkpad elements should implement custom event handlers.
3561  *
3562  * Returns: TRUE if the event was sent succesfully.
3563  */
3564 gboolean
3565 gst_pad_event_default (GstPad * pad, GstEvent * event)
3566 {
3567   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
3568   g_return_val_if_fail (event != NULL, FALSE);
3569
3570   GST_LOG_OBJECT (pad, "default event handler");
3571
3572   switch (GST_EVENT_TYPE (event)) {
3573     case GST_EVENT_EOS:
3574     {
3575       GST_DEBUG_OBJECT (pad, "pausing task because of eos");
3576       gst_pad_pause_task (pad);
3577     }
3578       /* fall thru */
3579     default:
3580       break;
3581   }
3582
3583   return gst_pad_event_default_dispatch (pad, event);
3584 }
3585
3586 /**
3587  * gst_pad_dispatcher:
3588  * @pad: a #GstPad to dispatch.
3589  * @dispatch: the #GstPadDispatcherFunction to call.
3590  * @data: gpointer user data passed to the dispatcher function.
3591  *
3592  * Invokes the given dispatcher function on each respective peer of
3593  * all pads that are internally linked to the given pad.
3594  * The GstPadDispatcherFunction should return TRUE when no further pads
3595  * need to be processed.
3596  *
3597  * Returns: TRUE if one of the dispatcher functions returned TRUE.
3598  */
3599 gboolean
3600 gst_pad_dispatcher (GstPad * pad, GstPadDispatcherFunction dispatch,
3601     gpointer data)
3602 {
3603   gboolean res = FALSE;
3604   GstIterator *iter = NULL;
3605   gboolean done = FALSE;
3606   gpointer item;
3607
3608   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
3609   g_return_val_if_fail (dispatch != NULL, FALSE);
3610
3611   iter = gst_pad_iterate_internal_links (pad);
3612
3613   if (!iter)
3614     goto no_iter;
3615
3616   while (!done) {
3617     switch (gst_iterator_next (iter, &item)) {
3618       case GST_ITERATOR_OK:
3619       {
3620         GstPad *int_pad = GST_PAD_CAST (item);
3621         GstPad *int_peer = gst_pad_get_peer (int_pad);
3622
3623         if (int_peer) {
3624           GST_DEBUG_OBJECT (int_pad, "dispatching to peer %s:%s",
3625               GST_DEBUG_PAD_NAME (int_peer));
3626           done = res = dispatch (int_peer, data);
3627           gst_object_unref (int_peer);
3628         } else {
3629           GST_DEBUG_OBJECT (int_pad, "no peer");
3630         }
3631       }
3632         gst_object_unref (item);
3633         break;
3634       case GST_ITERATOR_RESYNC:
3635         gst_iterator_resync (iter);
3636         break;
3637       case GST_ITERATOR_ERROR:
3638         done = TRUE;
3639         GST_ERROR_OBJECT (pad, "Could not iterate internally linked pads");
3640         break;
3641       case GST_ITERATOR_DONE:
3642         done = TRUE;
3643         break;
3644     }
3645   }
3646   gst_iterator_free (iter);
3647
3648   GST_DEBUG_OBJECT (pad, "done, result %d", res);
3649
3650 no_iter:
3651
3652   return res;
3653 }
3654
3655 /**
3656  * gst_pad_query:
3657  * @pad: a #GstPad to invoke the default query on.
3658  * @query: the #GstQuery to perform.
3659  *
3660  * Dispatches a query to a pad. The query should have been allocated by the
3661  * caller via one of the type-specific allocation functions in gstquery.h. The
3662  * element is responsible for filling the query with an appropriate response,
3663  * which should then be parsed with a type-specific query parsing function.
3664  *
3665  * Again, the caller is responsible for both the allocation and deallocation of
3666  * the query structure.
3667  *
3668  * Returns: TRUE if the query could be performed.
3669  */
3670 gboolean
3671 gst_pad_query (GstPad * pad, GstQuery * query)
3672 {
3673   GstPadQueryFunction func;
3674
3675   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
3676   g_return_val_if_fail (GST_IS_QUERY (query), FALSE);
3677
3678   GST_DEBUG_OBJECT (pad, "sending query %p", query);
3679
3680   if ((func = GST_PAD_QUERYFUNC (pad)) == NULL)
3681     goto no_func;
3682
3683   return func (pad, query);
3684
3685 no_func:
3686   {
3687     GST_DEBUG_OBJECT (pad, "had no query function");
3688     return FALSE;
3689   }
3690 }
3691
3692 /**
3693  * gst_pad_peer_query:
3694  * @pad: a #GstPad to invoke the peer query on.
3695  * @query: the #GstQuery to perform.
3696  *
3697  * Performs gst_pad_query() on the peer of @pad.
3698  *
3699  * The caller is responsible for both the allocation and deallocation of
3700  * the query structure.
3701  *
3702  * Returns: TRUE if the query could be performed. This function returns %FALSE
3703  * if @pad has no peer.
3704  *
3705  * Since: 0.10.15
3706  */
3707 gboolean
3708 gst_pad_peer_query (GstPad * pad, GstQuery * query)
3709 {
3710   GstPad *peerpad;
3711   gboolean result;
3712
3713   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
3714   g_return_val_if_fail (GST_IS_QUERY (query), FALSE);
3715
3716   GST_OBJECT_LOCK (pad);
3717
3718   GST_DEBUG_OBJECT (pad, "peer query");
3719
3720   peerpad = GST_PAD_PEER (pad);
3721   if (G_UNLIKELY (peerpad == NULL))
3722     goto no_peer;
3723
3724   gst_object_ref (peerpad);
3725   GST_OBJECT_UNLOCK (pad);
3726
3727   result = gst_pad_query (peerpad, query);
3728
3729   gst_object_unref (peerpad);
3730
3731   return result;
3732
3733   /* ERRORS */
3734 no_peer:
3735   {
3736     GST_WARNING_OBJECT (pad, "pad has no peer");
3737     GST_OBJECT_UNLOCK (pad);
3738     return FALSE;
3739   }
3740 }
3741
3742 /**
3743  * gst_pad_query_default:
3744  * @pad: a #GstPad to call the default query handler on.
3745  * @query: the #GstQuery to handle.
3746  *
3747  * Invokes the default query handler for the given pad.
3748  * The query is sent to all pads internally linked to @pad. Note that
3749  * if there are many possible sink pads that are internally linked to
3750  * @pad, only one will be sent the query.
3751  * Multi-sinkpad elements should implement custom query handlers.
3752  *
3753  * Returns: TRUE if the query was performed succesfully.
3754  */
3755 gboolean
3756 gst_pad_query_default (GstPad * pad, GstQuery * query)
3757 {
3758   switch (GST_QUERY_TYPE (query)) {
3759     case GST_QUERY_POSITION:
3760     case GST_QUERY_SEEKING:
3761     case GST_QUERY_FORMATS:
3762     case GST_QUERY_LATENCY:
3763     case GST_QUERY_JITTER:
3764     case GST_QUERY_RATE:
3765     case GST_QUERY_CONVERT:
3766     default:
3767       return gst_pad_dispatcher
3768           (pad, (GstPadDispatcherFunction) gst_pad_query, query);
3769   }
3770 }
3771
3772 #if !defined(GST_DISABLE_LOADSAVE) && !defined(GST_REMOVE_DEPRECATED)
3773 /* FIXME: why isn't this on a GstElement ? */
3774 /**
3775  * gst_pad_load_and_link:
3776  * @self: an #xmlNodePtr to read the description from.
3777  * @parent: the #GstObject element that owns the pad.
3778  *
3779  * Reads the pad definition from the XML node and links the given pad
3780  * in the element to a pad of an element up in the hierarchy.
3781  */
3782 void
3783 gst_pad_load_and_link (xmlNodePtr self, GstObject * parent)
3784 {
3785   xmlNodePtr field = self->xmlChildrenNode;
3786   GstPad *pad = NULL, *targetpad;
3787   GstPadTemplate *tmpl;
3788   gchar *peer = NULL;
3789   gchar **split;
3790   GstElement *target;
3791   GstObject *grandparent;
3792   gchar *name = NULL;
3793
3794   while (field) {
3795     if (!strcmp ((char *) field->name, "name")) {
3796       name = (gchar *) xmlNodeGetContent (field);
3797       pad = gst_element_get_static_pad (GST_ELEMENT (parent), name);
3798       if ((!pad) || ((tmpl = gst_pad_get_pad_template (pad))
3799               && (GST_PAD_REQUEST == GST_PAD_TEMPLATE_PRESENCE (tmpl))))
3800         pad = gst_element_get_request_pad (GST_ELEMENT (parent), name);
3801       g_free (name);
3802     } else if (!strcmp ((char *) field->name, "peer")) {
3803       peer = (gchar *) xmlNodeGetContent (field);
3804     }
3805     field = field->next;
3806   }
3807   g_return_if_fail (pad != NULL);
3808
3809   if (peer == NULL)
3810     return;
3811
3812   split = g_strsplit (peer, ".", 2);
3813
3814   if (split[0] == NULL || split[1] == NULL) {
3815     GST_CAT_DEBUG_OBJECT (GST_CAT_XML, pad,
3816         "Could not parse peer '%s', leaving unlinked", peer);
3817
3818     g_free (peer);
3819     return;
3820   }
3821   g_free (peer);
3822
3823   g_return_if_fail (split[0] != NULL);
3824   g_return_if_fail (split[1] != NULL);
3825
3826   grandparent = gst_object_get_parent (parent);
3827
3828   if (grandparent && GST_IS_BIN (grandparent)) {
3829     target = gst_bin_get_by_name_recurse_up (GST_BIN (grandparent), split[0]);
3830   } else
3831     goto cleanup;
3832
3833   if (target == NULL)
3834     goto cleanup;
3835
3836   targetpad = gst_element_get_static_pad (target, split[1]);
3837   if (!targetpad)
3838     targetpad = gst_element_get_request_pad (target, split[1]);
3839
3840   if (targetpad == NULL)
3841     goto cleanup;
3842
3843   if (gst_pad_get_direction (pad) == GST_PAD_SRC)
3844     gst_pad_link (pad, targetpad);
3845   else
3846     gst_pad_link (targetpad, pad);
3847
3848 cleanup:
3849   g_strfreev (split);
3850 }
3851
3852 /**
3853  * gst_pad_save_thyself:
3854  * @pad: a #GstPad to save.
3855  * @parent: the parent #xmlNodePtr to save the description in.
3856  *
3857  * Saves the pad into an xml representation.
3858  *
3859  * Returns: the #xmlNodePtr representation of the pad.
3860  */
3861 static xmlNodePtr
3862 gst_pad_save_thyself (GstObject * object, xmlNodePtr parent)
3863 {
3864   GstPad *pad;
3865   GstPad *peer;
3866
3867   g_return_val_if_fail (GST_IS_PAD (object), NULL);
3868
3869   pad = GST_PAD_CAST (object);
3870
3871   xmlNewChild (parent, NULL, (xmlChar *) "name",
3872       (xmlChar *) GST_PAD_NAME (pad));
3873
3874   if (GST_PAD_IS_SRC (pad)) {
3875     xmlNewChild (parent, NULL, (xmlChar *) "direction", (xmlChar *) "source");
3876   } else if (GST_PAD_IS_SINK (pad)) {
3877     xmlNewChild (parent, NULL, (xmlChar *) "direction", (xmlChar *) "sink");
3878   } else {
3879     xmlNewChild (parent, NULL, (xmlChar *) "direction", (xmlChar *) "unknown");
3880   }
3881
3882   if (GST_PAD_PEER (pad) != NULL) {
3883     gchar *content;
3884
3885     peer = GST_PAD_PEER (pad);
3886     /* first check to see if the peer's parent's parent is the same */
3887     /* we just save it off */
3888     content = g_strdup_printf ("%s.%s",
3889         GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer));
3890     xmlNewChild (parent, NULL, (xmlChar *) "peer", (xmlChar *) content);
3891     g_free (content);
3892   } else
3893     xmlNewChild (parent, NULL, (xmlChar *) "peer", NULL);
3894
3895   return parent;
3896 }
3897
3898 #if 0
3899 /**
3900  * gst_ghost_pad_save_thyself:
3901  * @pad: a ghost #GstPad to save.
3902  * @parent: the parent #xmlNodePtr to save the description in.
3903  *
3904  * Saves the ghost pad into an xml representation.
3905  *
3906  * Returns: the #xmlNodePtr representation of the pad.
3907  */
3908 xmlNodePtr
3909 gst_ghost_pad_save_thyself (GstPad * pad, xmlNodePtr parent)
3910 {
3911   xmlNodePtr self;
3912
3913   g_return_val_if_fail (GST_IS_GHOST_PAD (pad), NULL);
3914
3915   self = xmlNewChild (parent, NULL, (xmlChar *) "ghostpad", NULL);
3916   xmlNewChild (self, NULL, (xmlChar *) "name", (xmlChar *) GST_PAD_NAME (pad));
3917   xmlNewChild (self, NULL, (xmlChar *) "parent",
3918       (xmlChar *) GST_OBJECT_NAME (GST_PAD_PARENT (pad)));
3919
3920   /* FIXME FIXME FIXME! */
3921
3922   return self;
3923 }
3924 #endif /* 0 */
3925 #endif /* GST_DISABLE_LOADSAVE */
3926
3927 /*
3928  * should be called with pad OBJECT_LOCK and STREAM_LOCK held.
3929  * GST_PAD_IS_BLOCKED (pad) == TRUE when this function is
3930  * called.
3931  *
3932  * This function performs the pad blocking when an event, buffer push
3933  * or buffer_alloc is performed on a _SRC_ pad. It blocks the
3934  * streaming thread after informing the pad has been blocked.
3935  *
3936  * An application can with this method wait and block any streaming
3937  * thread and perform operations such as seeking or linking.
3938  *
3939  * Two methods are available for notifying the application of the
3940  * block:
3941  * - the callback method, which happens in the STREAMING thread with
3942  *   the STREAM_LOCK held. With this method, the most useful way of
3943  *   dealing with the callback is to post a message to the main thread
3944  *   where the pad block can then be handled outside of the streaming
3945  *   thread. With the last method one can perform all operations such
3946  *   as doing a state change, linking, unblocking, seeking etc on the
3947  *   pad.
3948  * - the GCond signal method, which makes any thread unblock when
3949  *   the pad block happens.
3950  *
3951  * During the actual blocking state, the GST_PAD_BLOCKING flag is set.
3952  * The GST_PAD_BLOCKING flag is unset when the pad was unblocked.
3953  *
3954  * MT safe.
3955  */
3956 static GstFlowReturn
3957 handle_pad_block (GstPad * pad)
3958 {
3959   GstPadBlockCallback callback;
3960   gpointer user_data;
3961   GstFlowReturn ret = GST_FLOW_OK;
3962
3963   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "signal block taken");
3964
3965   /* flushing, don't bother trying to block and return WRONG_STATE
3966    * right away */
3967   if (GST_PAD_IS_FLUSHING (pad))
3968     goto flushingnonref;
3969
3970   /* we grab an extra ref for the callbacks, this is probably not
3971    * needed (callback code does not have a ref and cannot unref). I
3972    * think this was done to make it possible to unref the element in
3973    * the callback, which is in the end totally impossible as it
3974    * requires grabbing the STREAM_LOCK and OBJECT_LOCK which are
3975    * all taken when calling this function. */
3976   gst_object_ref (pad);
3977
3978   while (GST_PAD_IS_BLOCKED (pad)) {
3979     do {
3980       /* we either have a callback installed to notify the block or
3981        * some other thread is doing a GCond wait. */
3982       callback = pad->block_callback;
3983       pad->abidata.ABI.block_callback_called = TRUE;
3984       if (callback) {
3985         /* there is a callback installed, call it. We release the
3986          * lock so that the callback can do something usefull with the
3987          * pad */
3988         user_data = pad->block_data;
3989         GST_OBJECT_UNLOCK (pad);
3990         callback (pad, TRUE, user_data);
3991         GST_OBJECT_LOCK (pad);
3992
3993         /* we released the lock, recheck flushing */
3994         if (GST_PAD_IS_FLUSHING (pad))
3995           goto flushing;
3996       } else {
3997         /* no callback, signal the thread that is doing a GCond wait
3998          * if any. */
3999         GST_PAD_BLOCK_BROADCAST (pad);
4000       }
4001     } while (pad->abidata.ABI.block_callback_called == FALSE
4002         && GST_PAD_IS_BLOCKED (pad));
4003
4004     /* OBJECT_LOCK could have been released when we did the callback, which
4005      * then could have made the pad unblock so we need to check the blocking
4006      * condition again.   */
4007     if (!GST_PAD_IS_BLOCKED (pad))
4008       break;
4009
4010     /* now we block the streaming thread. It can be unlocked when we
4011      * deactivate the pad (which will also set the FLUSHING flag) or
4012      * when the pad is unblocked. A flushing event will also unblock
4013      * the pad after setting the FLUSHING flag. */
4014     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4015         "Waiting to be unblocked or set flushing");
4016     GST_OBJECT_FLAG_SET (pad, GST_PAD_BLOCKING);
4017     GST_PAD_BLOCK_WAIT (pad);
4018     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_BLOCKING);
4019
4020     /* see if we got unblocked by a flush or not */
4021     if (GST_PAD_IS_FLUSHING (pad))
4022       goto flushing;
4023   }
4024
4025   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "got unblocked");
4026
4027   /* when we get here, the pad is unblocked again and we perform
4028    * the needed unblock code. */
4029   callback = pad->block_callback;
4030   if (callback) {
4031     /* we need to call the callback */
4032     user_data = pad->block_data;
4033     GST_OBJECT_UNLOCK (pad);
4034     callback (pad, FALSE, user_data);
4035     GST_OBJECT_LOCK (pad);
4036   } else {
4037     /* we need to signal the thread waiting on the GCond */
4038     GST_PAD_BLOCK_BROADCAST (pad);
4039   }
4040
4041   gst_object_unref (pad);
4042
4043   return ret;
4044
4045 flushingnonref:
4046   {
4047     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "pad was flushing");
4048     return GST_FLOW_WRONG_STATE;
4049   }
4050 flushing:
4051   {
4052     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "pad became flushing");
4053     gst_object_unref (pad);
4054     return GST_FLOW_WRONG_STATE;
4055   }
4056 }
4057
4058 /**********************************************************************
4059  * Data passing functions
4060  */
4061
4062 static gboolean
4063 gst_pad_emit_have_data_signal (GstPad * pad, GstMiniObject * obj)
4064 {
4065   GValue ret = { 0 };
4066   GValue args[2] = { {0}, {0} };
4067   gboolean res;
4068   GQuark detail;
4069
4070   /* init */
4071   g_value_init (&ret, G_TYPE_BOOLEAN);
4072   g_value_set_boolean (&ret, TRUE);
4073   g_value_init (&args[0], GST_TYPE_PAD);
4074   g_value_set_object (&args[0], pad);
4075   g_value_init (&args[1], GST_TYPE_MINI_OBJECT);
4076   gst_value_set_mini_object (&args[1], obj);
4077
4078   if (GST_IS_EVENT (obj))
4079     detail = event_quark;
4080   else
4081     detail = buffer_quark;
4082
4083   /* actually emit */
4084   g_signal_emitv (args, gst_pad_signals[PAD_HAVE_DATA], detail, &ret);
4085   res = g_value_get_boolean (&ret);
4086
4087   /* clean up */
4088   g_value_unset (&ret);
4089   g_value_unset (&args[0]);
4090   g_value_unset (&args[1]);
4091
4092   return res;
4093 }
4094
4095 static void
4096 gst_pad_data_unref (gboolean is_buffer, void *data)
4097 {
4098   if (G_LIKELY (is_buffer)) {
4099     gst_buffer_unref (data);
4100   } else {
4101     gst_buffer_list_unref (data);
4102   }
4103 }
4104
4105 static GstCaps *
4106 gst_pad_data_get_caps (gboolean is_buffer, void *data)
4107 {
4108   GstCaps *caps;
4109
4110   if (G_LIKELY (is_buffer)) {
4111     caps = GST_BUFFER_CAPS (data);
4112   } else {
4113     GstBuffer *buf;
4114
4115     if ((buf = gst_buffer_list_get (GST_BUFFER_LIST_CAST (data), 0, 0)))
4116       caps = GST_BUFFER_CAPS (buf);
4117     else
4118       caps = NULL;
4119   }
4120   return caps;
4121 }
4122
4123 /* this is the chain function that does not perform the additional argument
4124  * checking for that little extra speed.
4125  */
4126 static inline GstFlowReturn
4127 gst_pad_chain_data_unchecked (GstPad * pad, gboolean is_buffer, void *data)
4128 {
4129   GstCaps *caps;
4130   gboolean caps_changed;
4131   GstFlowReturn ret;
4132   gboolean emit_signal;
4133
4134   GST_PAD_STREAM_LOCK (pad);
4135
4136   GST_OBJECT_LOCK (pad);
4137   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4138     goto flushing;
4139
4140   caps = gst_pad_data_get_caps (is_buffer, data);
4141   caps_changed = caps && caps != GST_PAD_CAPS (pad);
4142
4143   emit_signal = GST_PAD_DO_BUFFER_SIGNALS (pad) > 0;
4144   GST_OBJECT_UNLOCK (pad);
4145
4146   /* see if the signal should be emited, we emit before caps nego as
4147    * we might drop the buffer and do capsnego for nothing. */
4148   if (G_UNLIKELY (emit_signal)) {
4149     if (G_LIKELY (is_buffer)) {
4150       if (!gst_pad_emit_have_data_signal (pad, GST_MINI_OBJECT (data)))
4151         goto dropping;
4152     } else {
4153       /* chain all groups in the buffer list one by one to avoid problems with
4154        * buffer probes that push buffers or events */
4155       goto chain_groups;
4156     }
4157   }
4158
4159   /* we got a new datatype on the pad, see if it can handle it */
4160   if (G_UNLIKELY (caps_changed)) {
4161     GST_DEBUG_OBJECT (pad, "caps changed to %p %" GST_PTR_FORMAT, caps, caps);
4162     if (G_UNLIKELY (!gst_pad_configure_sink (pad, caps)))
4163       goto not_negotiated;
4164   }
4165
4166   /* NOTE: we read the chainfunc unlocked.
4167    * we cannot hold the lock for the pad so we might send
4168    * the data to the wrong function. This is not really a
4169    * problem since functions are assigned at creation time
4170    * and don't change that often... */
4171   if (G_LIKELY (is_buffer)) {
4172     GstPadChainFunction chainfunc;
4173
4174     if (G_UNLIKELY ((chainfunc = GST_PAD_CHAINFUNC (pad)) == NULL))
4175       goto no_function;
4176
4177     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4178         "calling chainfunction &%s", GST_DEBUG_FUNCPTR_NAME (chainfunc));
4179
4180     ret = chainfunc (pad, GST_BUFFER_CAST (data));
4181
4182     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4183         "called chainfunction &%s, returned %s",
4184         GST_DEBUG_FUNCPTR_NAME (chainfunc), gst_flow_get_name (ret));
4185   } else {
4186     GstPadChainListFunction chainlistfunc;
4187
4188     if (G_UNLIKELY ((chainlistfunc = GST_PAD_CHAINLISTFUNC (pad)) == NULL))
4189       goto chain_groups;
4190
4191     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4192         "calling chainlistfunction &%s",
4193         GST_DEBUG_FUNCPTR_NAME (chainlistfunc));
4194
4195     ret = chainlistfunc (pad, GST_BUFFER_LIST_CAST (data));
4196
4197     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4198         "called chainlistfunction &%s, returned %s",
4199         GST_DEBUG_FUNCPTR_NAME (chainlistfunc), gst_flow_get_name (ret));
4200   }
4201
4202   GST_PAD_STREAM_UNLOCK (pad);
4203
4204   return ret;
4205
4206 chain_groups:
4207   {
4208     GstBufferList *list;
4209     GstBufferListIterator *it;
4210     GstBuffer *group;
4211
4212     GST_PAD_STREAM_UNLOCK (pad);
4213
4214     GST_INFO_OBJECT (pad, "chaining each group in list as a merged buffer");
4215
4216     list = GST_BUFFER_LIST_CAST (data);
4217     it = gst_buffer_list_iterate (list);
4218
4219     if (gst_buffer_list_iterator_next_group (it)) {
4220       do {
4221         group = gst_buffer_list_iterator_merge_group (it);
4222         if (group == NULL) {
4223           group = gst_buffer_new ();
4224           GST_CAT_INFO_OBJECT (GST_CAT_SCHEDULING, pad, "chaining empty group");
4225         } else {
4226           GST_CAT_INFO_OBJECT (GST_CAT_SCHEDULING, pad, "chaining group");
4227         }
4228         ret = gst_pad_chain_data_unchecked (pad, TRUE, group);
4229       } while (ret == GST_FLOW_OK && gst_buffer_list_iterator_next_group (it));
4230     } else {
4231       GST_CAT_INFO_OBJECT (GST_CAT_SCHEDULING, pad, "chaining empty group");
4232       ret = gst_pad_chain_data_unchecked (pad, TRUE, gst_buffer_new ());
4233     }
4234
4235     gst_buffer_list_iterator_free (it);
4236     gst_buffer_list_unref (list);
4237
4238     return ret;
4239   }
4240
4241   /* ERRORS */
4242 flushing:
4243   {
4244     gst_pad_data_unref (is_buffer, data);
4245     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4246         "pushing, but pad was flushing");
4247     GST_OBJECT_UNLOCK (pad);
4248     GST_PAD_STREAM_UNLOCK (pad);
4249     return GST_FLOW_WRONG_STATE;
4250   }
4251 dropping:
4252   {
4253     gst_pad_data_unref (is_buffer, data);
4254     GST_DEBUG_OBJECT (pad, "Dropping buffer due to FALSE probe return");
4255     GST_PAD_STREAM_UNLOCK (pad);
4256     return GST_FLOW_OK;
4257   }
4258 not_negotiated:
4259   {
4260     gst_pad_data_unref (is_buffer, data);
4261     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4262         "pushing data but pad did not accept");
4263     GST_PAD_STREAM_UNLOCK (pad);
4264     return GST_FLOW_NOT_NEGOTIATED;
4265   }
4266 no_function:
4267   {
4268     gst_pad_data_unref (is_buffer, data);
4269     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4270         "pushing, but not chainhandler");
4271     GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
4272         ("push on pad %s:%s but it has no chainfunction",
4273             GST_DEBUG_PAD_NAME (pad)));
4274     GST_PAD_STREAM_UNLOCK (pad);
4275     return GST_FLOW_NOT_SUPPORTED;
4276   }
4277 }
4278
4279 /**
4280  * gst_pad_chain:
4281  * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not.
4282  * @buffer: the #GstBuffer to send, return GST_FLOW_ERROR if not.
4283  *
4284  * Chain a buffer to @pad.
4285  *
4286  * The function returns #GST_FLOW_WRONG_STATE if the pad was flushing.
4287  *
4288  * If the caps on @buffer are different from the current caps on @pad, this
4289  * function will call any setcaps function (see gst_pad_set_setcaps_function())
4290  * installed on @pad. If the new caps are not acceptable for @pad, this
4291  * function returns #GST_FLOW_NOT_NEGOTIATED.
4292  *
4293  * The function proceeds calling the chain function installed on @pad (see
4294  * gst_pad_set_chain_function()) and the return value of that function is
4295  * returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no
4296  * chain function.
4297  *
4298  * In all cases, success or failure, the caller loses its reference to @buffer
4299  * after calling this function.
4300  *
4301  * Returns: a #GstFlowReturn from the pad.
4302  *
4303  * MT safe.
4304  */
4305 GstFlowReturn
4306 gst_pad_chain (GstPad * pad, GstBuffer * buffer)
4307 {
4308   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4309   g_return_val_if_fail (GST_PAD_IS_SINK (pad), GST_FLOW_ERROR);
4310   g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
4311
4312   return gst_pad_chain_data_unchecked (pad, TRUE, buffer);
4313 }
4314
4315 /**
4316  * gst_pad_chain_list:
4317  * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not.
4318  * @list: the #GstBufferList to send, return GST_FLOW_ERROR if not.
4319  *
4320  * Chain a bufferlist to @pad.
4321  *
4322  * The function returns #GST_FLOW_WRONG_STATE if the pad was flushing.
4323  *
4324  * If the caps on the first buffer of @list are different from the current
4325  * caps on @pad, this function will call any setcaps function
4326  * (see gst_pad_set_setcaps_function()) installed on @pad. If the new caps
4327  * are not acceptable for @pad, this function returns #GST_FLOW_NOT_NEGOTIATED.
4328  *
4329  * The function proceeds calling the chainlist function installed on @pad (see
4330  * gst_pad_set_chain_list_function()) and the return value of that function is
4331  * returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no
4332  * chainlist function.
4333  *
4334  * In all cases, success or failure, the caller loses its reference to @list
4335  * after calling this function.
4336  *
4337  * MT safe.
4338  *
4339  * Returns: a #GstFlowReturn from the pad.
4340  *
4341  * Since: 0.10.24
4342  */
4343 GstFlowReturn
4344 gst_pad_chain_list (GstPad * pad, GstBufferList * list)
4345 {
4346   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4347   g_return_val_if_fail (GST_PAD_IS_SINK (pad), GST_FLOW_ERROR);
4348   g_return_val_if_fail (GST_IS_BUFFER_LIST (list), GST_FLOW_ERROR);
4349
4350   return gst_pad_chain_data_unchecked (pad, FALSE, list);
4351 }
4352
4353 static GstFlowReturn
4354 gst_pad_push_data (GstPad * pad, gboolean is_buffer, void *data)
4355 {
4356   GstPad *peer;
4357   GstFlowReturn ret;
4358   GstCaps *caps;
4359   gboolean caps_changed;
4360
4361   GST_OBJECT_LOCK (pad);
4362
4363   /* FIXME: this check can go away; pad_set_blocked could be implemented with
4364    * probes completely or probes with an extended pad block. */
4365   while (G_UNLIKELY (GST_PAD_IS_BLOCKED (pad)))
4366     if ((ret = handle_pad_block (pad)) != GST_FLOW_OK)
4367       goto flushed;
4368
4369   /* we emit signals on the pad arg, the peer will have a chance to
4370    * emit in the _chain() function */
4371   if (G_UNLIKELY (GST_PAD_DO_BUFFER_SIGNALS (pad) > 0)) {
4372     /* unlock before emitting */
4373     GST_OBJECT_UNLOCK (pad);
4374
4375     if (G_LIKELY (is_buffer)) {
4376       /* if the signal handler returned FALSE, it means we should just drop the
4377        * buffer */
4378       if (!gst_pad_emit_have_data_signal (pad, GST_MINI_OBJECT (data)))
4379         goto dropped;
4380     } else {
4381       /* push all buffers in the list */
4382       goto push_groups;
4383     }
4384     GST_OBJECT_LOCK (pad);
4385   }
4386
4387   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
4388     goto not_linked;
4389
4390   /* Before pushing the buffer to the peer pad, ensure that caps
4391    * are set on this pad */
4392   caps = gst_pad_data_get_caps (is_buffer, data);
4393   caps_changed = caps && caps != GST_PAD_CAPS (pad);
4394
4395   /* take ref to peer pad before releasing the lock */
4396   gst_object_ref (peer);
4397
4398   GST_OBJECT_UNLOCK (pad);
4399
4400   /* we got a new datatype from the pad, it had better handle it */
4401   if (G_UNLIKELY (caps_changed)) {
4402     GST_DEBUG_OBJECT (pad,
4403         "caps changed from %" GST_PTR_FORMAT " to %p %" GST_PTR_FORMAT,
4404         GST_PAD_CAPS (pad), caps, caps);
4405     if (G_UNLIKELY (!gst_pad_set_caps (pad, caps)))
4406       goto not_negotiated;
4407   }
4408
4409   ret = gst_pad_chain_data_unchecked (peer, is_buffer, data);
4410
4411   gst_object_unref (peer);
4412
4413   return ret;
4414
4415 push_groups:
4416   {
4417     GstBufferList *list;
4418     GstBufferListIterator *it;
4419     GstBuffer *group;
4420
4421     GST_INFO_OBJECT (pad, "pushing each group in list as a merged buffer");
4422
4423     list = GST_BUFFER_LIST_CAST (data);
4424     it = gst_buffer_list_iterate (list);
4425
4426     if (gst_buffer_list_iterator_next_group (it)) {
4427       do {
4428         group = gst_buffer_list_iterator_merge_group (it);
4429         if (group == NULL) {
4430           group = gst_buffer_new ();
4431           GST_CAT_INFO_OBJECT (GST_CAT_SCHEDULING, pad, "pushing empty group");
4432         } else {
4433           GST_CAT_INFO_OBJECT (GST_CAT_SCHEDULING, pad, "pushing group");
4434         }
4435         ret = gst_pad_push_data (pad, TRUE, group);
4436       } while (ret == GST_FLOW_OK && gst_buffer_list_iterator_next_group (it));
4437     } else {
4438       GST_CAT_INFO_OBJECT (GST_CAT_SCHEDULING, pad, "pushing empty group");
4439       ret = gst_pad_push_data (pad, TRUE, gst_buffer_new ());
4440     }
4441
4442     gst_buffer_list_iterator_free (it);
4443     gst_buffer_list_unref (list);
4444
4445     return ret;
4446   }
4447
4448   /* ERROR recovery here */
4449 flushed:
4450   {
4451     gst_pad_data_unref (is_buffer, data);
4452     GST_DEBUG_OBJECT (pad, "pad block stopped by flush");
4453     GST_OBJECT_UNLOCK (pad);
4454     return ret;
4455   }
4456 dropped:
4457   {
4458     gst_pad_data_unref (is_buffer, data);
4459     GST_DEBUG_OBJECT (pad, "Dropping buffer due to FALSE probe return");
4460     return GST_FLOW_OK;
4461   }
4462 not_linked:
4463   {
4464     gst_pad_data_unref (is_buffer, data);
4465     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4466         "pushing, but it was not linked");
4467     GST_OBJECT_UNLOCK (pad);
4468     return GST_FLOW_NOT_LINKED;
4469   }
4470 not_negotiated:
4471   {
4472     gst_pad_data_unref (is_buffer, data);
4473     gst_object_unref (peer);
4474     GST_CAT_DEBUG_OBJECT (GST_CAT_SCHEDULING, pad,
4475         "element pushed data then refused to accept the caps");
4476     return GST_FLOW_NOT_NEGOTIATED;
4477   }
4478 }
4479
4480 /**
4481  * gst_pad_push:
4482  * @pad: a source #GstPad, returns #GST_FLOW_ERROR if not.
4483  * @buffer: the #GstBuffer to push returns GST_FLOW_ERROR if not.
4484  *
4485  * Pushes a buffer to the peer of @pad.
4486  *
4487  * This function will call an installed pad block before triggering any
4488  * installed pad probes.
4489  *
4490  * If the caps on @buffer are different from the currently configured caps on
4491  * @pad, this function will call any installed setcaps function on @pad (see
4492  * gst_pad_set_setcaps_function()). In case of failure to renegotiate the new
4493  * format, this function returns #GST_FLOW_NOT_NEGOTIATED.
4494  *
4495  * The function proceeds calling gst_pad_chain() on the peer pad and returns
4496  * the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will
4497  * be returned.
4498  *
4499  * In all cases, success or failure, the caller loses its reference to @buffer
4500  * after calling this function.
4501  *
4502  * Returns: a #GstFlowReturn from the peer pad.
4503  *
4504  * MT safe.
4505  */
4506 GstFlowReturn
4507 gst_pad_push (GstPad * pad, GstBuffer * buffer)
4508 {
4509   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4510   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
4511   g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
4512
4513   return gst_pad_push_data (pad, TRUE, buffer);
4514 }
4515
4516 /**
4517  * gst_pad_push_list:
4518  * @pad: a source #GstPad, returns #GST_FLOW_ERROR if not.
4519  * @list: the #GstBufferList to push returns GST_FLOW_ERROR if not.
4520  *
4521  * Pushes a buffer list to the peer of @pad.
4522  *
4523  * This function will call an installed pad block before triggering any
4524  * installed pad probes.
4525  *
4526  * If the caps on the first buffer in the first group of @list are different
4527  * from the currently configured caps on @pad, this function will call any
4528  * installed setcaps function on @pad (see gst_pad_set_setcaps_function()). In
4529  * case of failure to renegotiate the new format, this function returns
4530  * #GST_FLOW_NOT_NEGOTIATED.
4531  *
4532  * If there are any probes installed on @pad every group of the buffer list
4533  * will be merged into a normal #GstBuffer and pushed via gst_pad_push and the
4534  * buffer list will be unreffed.
4535  *
4536  * The function proceeds calling the chain function on the peer pad and returns
4537  * the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will
4538  * be returned. If the peer pad does not have any installed chainlist function
4539  * every group buffer of the list will be merged into a normal #GstBuffer and
4540  * chained via gst_pad_chain().
4541  *
4542  * In all cases, success or failure, the caller loses its reference to @list
4543  * after calling this function.
4544  *
4545  * Returns: a #GstFlowReturn from the peer pad.
4546  *
4547  * MT safe.
4548  *
4549  * Since: 0.10.24
4550  */
4551 GstFlowReturn
4552 gst_pad_push_list (GstPad * pad, GstBufferList * list)
4553 {
4554   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4555   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
4556   g_return_val_if_fail (GST_IS_BUFFER_LIST (list), GST_FLOW_ERROR);
4557
4558   return gst_pad_push_data (pad, FALSE, list);
4559 }
4560
4561 /**
4562  * gst_pad_check_pull_range:
4563  * @pad: a sink #GstPad.
4564  *
4565  * Checks if a gst_pad_pull_range() can be performed on the peer
4566  * source pad. This function is used by plugins that want to check
4567  * if they can use random access on the peer source pad.
4568  *
4569  * The peer sourcepad can implement a custom #GstPadCheckGetRangeFunction
4570  * if it needs to perform some logic to determine if pull_range is
4571  * possible.
4572  *
4573  * Returns: a gboolean with the result.
4574  *
4575  * MT safe.
4576  */
4577 gboolean
4578 gst_pad_check_pull_range (GstPad * pad)
4579 {
4580   GstPad *peer;
4581   gboolean ret;
4582   GstPadCheckGetRangeFunction checkgetrangefunc;
4583
4584   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
4585
4586   GST_OBJECT_LOCK (pad);
4587   if (!GST_PAD_IS_SINK (pad))
4588     goto wrong_direction;
4589
4590   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
4591     goto not_connected;
4592
4593   gst_object_ref (peer);
4594   GST_OBJECT_UNLOCK (pad);
4595
4596   /* see note in above function */
4597   if (G_LIKELY ((checkgetrangefunc = peer->checkgetrangefunc) == NULL)) {
4598     /* FIXME, kindoff ghetto */
4599     ret = GST_PAD_GETRANGEFUNC (peer) != NULL;
4600     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4601         "no checkgetrangefunc, assuming %d", ret);
4602   } else {
4603     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4604         "calling checkgetrangefunc %s of peer pad %s:%s",
4605         GST_DEBUG_FUNCPTR_NAME (checkgetrangefunc), GST_DEBUG_PAD_NAME (peer));
4606
4607     ret = checkgetrangefunc (peer);
4608   }
4609
4610   gst_object_unref (peer);
4611
4612   return ret;
4613
4614   /* ERROR recovery here */
4615 wrong_direction:
4616   {
4617     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4618         "checking pull range, but pad must be a sinkpad");
4619     GST_OBJECT_UNLOCK (pad);
4620     return FALSE;
4621   }
4622 not_connected:
4623   {
4624     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4625         "checking pull range, but it was not linked");
4626     GST_OBJECT_UNLOCK (pad);
4627     return FALSE;
4628   }
4629 }
4630
4631 /**
4632  * gst_pad_get_range:
4633  * @pad: a src #GstPad, returns #GST_FLOW_ERROR if not.
4634  * @offset: The start offset of the buffer
4635  * @size: The length of the buffer
4636  * @buffer: a pointer to hold the #GstBuffer, returns #GST_FLOW_ERROR if %NULL.
4637  *
4638  * When @pad is flushing this function returns #GST_FLOW_WRONG_STATE
4639  * immediatly and @buffer is %NULL.
4640  *
4641  * Calls the getrange function of @pad, see #GstPadGetRangeFunction for a
4642  * description of a getrange function. If @pad has no getrange function
4643  * installed (see gst_pad_set_getrange_function()) this function returns
4644  * #GST_FLOW_NOT_SUPPORTED.
4645  *
4646  * This is a lowlevel function. Usualy gst_pad_pull_range() is used.
4647  *
4648  * Returns: a #GstFlowReturn from the pad.
4649  *
4650  * MT safe.
4651  */
4652 GstFlowReturn
4653 gst_pad_get_range (GstPad * pad, guint64 offset, guint size,
4654     GstBuffer ** buffer)
4655 {
4656   GstFlowReturn ret;
4657   GstPadGetRangeFunction getrangefunc;
4658   gboolean emit_signal;
4659   GstCaps *caps;
4660   gboolean caps_changed;
4661
4662   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4663   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
4664   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
4665
4666   GST_PAD_STREAM_LOCK (pad);
4667
4668   GST_OBJECT_LOCK (pad);
4669   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4670     goto flushing;
4671
4672   emit_signal = GST_PAD_DO_BUFFER_SIGNALS (pad) > 0;
4673   GST_OBJECT_UNLOCK (pad);
4674
4675   if (G_UNLIKELY ((getrangefunc = GST_PAD_GETRANGEFUNC (pad)) == NULL))
4676     goto no_function;
4677
4678   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4679       "calling getrangefunc %s, offset %"
4680       G_GUINT64_FORMAT ", size %u",
4681       GST_DEBUG_FUNCPTR_NAME (getrangefunc), offset, size);
4682
4683   ret = getrangefunc (pad, offset, size, buffer);
4684
4685   /* can only fire the signal if we have a valid buffer */
4686   if (G_UNLIKELY (emit_signal) && (ret == GST_FLOW_OK)) {
4687     if (!gst_pad_emit_have_data_signal (pad, GST_MINI_OBJECT (*buffer)))
4688       goto dropping;
4689   }
4690
4691   GST_PAD_STREAM_UNLOCK (pad);
4692
4693   if (G_UNLIKELY (ret != GST_FLOW_OK))
4694     goto get_range_failed;
4695
4696   GST_OBJECT_LOCK (pad);
4697   /* Before pushing the buffer to the peer pad, ensure that caps
4698    * are set on this pad */
4699   caps = GST_BUFFER_CAPS (*buffer);
4700   caps_changed = caps && caps != GST_PAD_CAPS (pad);
4701   GST_OBJECT_UNLOCK (pad);
4702
4703   if (G_UNLIKELY (caps_changed)) {
4704     GST_DEBUG_OBJECT (pad, "caps changed to %p %" GST_PTR_FORMAT, caps, caps);
4705     /* this should usually work because the element produced the buffer */
4706     if (G_UNLIKELY (!gst_pad_configure_src (pad, caps, TRUE)))
4707       goto not_negotiated;
4708   }
4709   return ret;
4710
4711   /* ERRORS */
4712 flushing:
4713   {
4714     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4715         "pulling range, but pad was flushing");
4716     GST_OBJECT_UNLOCK (pad);
4717     GST_PAD_STREAM_UNLOCK (pad);
4718     return GST_FLOW_WRONG_STATE;
4719   }
4720 no_function:
4721   {
4722     GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
4723         ("pullrange on pad %s:%s but it has no getrangefunction",
4724             GST_DEBUG_PAD_NAME (pad)));
4725     GST_PAD_STREAM_UNLOCK (pad);
4726     return GST_FLOW_NOT_SUPPORTED;
4727   }
4728 dropping:
4729   {
4730     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4731         "Dropping data after FALSE probe return");
4732     GST_PAD_STREAM_UNLOCK (pad);
4733     gst_buffer_unref (*buffer);
4734     *buffer = NULL;
4735     return GST_FLOW_UNEXPECTED;
4736   }
4737 get_range_failed:
4738   {
4739     *buffer = NULL;
4740     GST_CAT_LEVEL_LOG (GST_CAT_SCHEDULING,
4741         (ret >= GST_FLOW_UNEXPECTED) ? GST_LEVEL_INFO : GST_LEVEL_WARNING,
4742         pad, "getrange failed, flow: %s", gst_flow_get_name (ret));
4743     return ret;
4744   }
4745 not_negotiated:
4746   {
4747     gst_buffer_unref (*buffer);
4748     *buffer = NULL;
4749     GST_CAT_WARNING_OBJECT (GST_CAT_SCHEDULING, pad,
4750         "getrange returned buffer of unaccaptable caps");
4751     return GST_FLOW_NOT_NEGOTIATED;
4752   }
4753 }
4754
4755
4756 /**
4757  * gst_pad_pull_range:
4758  * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not.
4759  * @offset: The start offset of the buffer
4760  * @size: The length of the buffer
4761  * @buffer: a pointer to hold the #GstBuffer, returns GST_FLOW_ERROR if %NULL.
4762  *
4763  * Pulls a @buffer from the peer pad.
4764  *
4765  * This function will first trigger the pad block signal if it was
4766  * installed.
4767  *
4768  * When @pad is not linked #GST_FLOW_NOT_LINKED is returned else this
4769  * function returns the result of gst_pad_get_range() on the peer pad.
4770  * See gst_pad_get_range() for a list of return values and for the
4771  * semantics of the arguments of this function.
4772  *
4773  * @buffer's caps must either be unset or the same as what is already
4774  * configured on @pad. Renegotiation within a running pull-mode pipeline is not
4775  * supported.
4776  *
4777  * Returns: a #GstFlowReturn from the peer pad.
4778  * When this function returns #GST_FLOW_OK, @buffer will contain a valid
4779  * #GstBuffer that should be freed with gst_buffer_unref() after usage.
4780  * @buffer may not be used or freed when any other return value than
4781  * #GST_FLOW_OK is returned.
4782  *
4783  * MT safe.
4784  */
4785 GstFlowReturn
4786 gst_pad_pull_range (GstPad * pad, guint64 offset, guint size,
4787     GstBuffer ** buffer)
4788 {
4789   GstPad *peer;
4790   GstFlowReturn ret;
4791   gboolean emit_signal;
4792   GstCaps *caps;
4793   gboolean caps_changed;
4794
4795   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4796   g_return_val_if_fail (GST_PAD_IS_SINK (pad), GST_FLOW_ERROR);
4797   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
4798
4799   GST_OBJECT_LOCK (pad);
4800
4801   while (G_UNLIKELY (GST_PAD_IS_BLOCKED (pad)))
4802     handle_pad_block (pad);
4803
4804   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
4805     goto not_connected;
4806
4807   /* signal emision for the pad, peer has chance to emit when
4808    * we call _get_range() */
4809   emit_signal = GST_PAD_DO_BUFFER_SIGNALS (pad) > 0;
4810
4811   gst_object_ref (peer);
4812   GST_OBJECT_UNLOCK (pad);
4813
4814   ret = gst_pad_get_range (peer, offset, size, buffer);
4815
4816   gst_object_unref (peer);
4817
4818   if (G_UNLIKELY (ret != GST_FLOW_OK))
4819     goto pull_range_failed;
4820
4821   /* can only fire the signal if we have a valid buffer */
4822   if (G_UNLIKELY (emit_signal)) {
4823     if (!gst_pad_emit_have_data_signal (pad, GST_MINI_OBJECT (*buffer)))
4824       goto dropping;
4825   }
4826
4827   GST_OBJECT_LOCK (pad);
4828   /* Before pushing the buffer to the peer pad, ensure that caps
4829    * are set on this pad */
4830   caps = GST_BUFFER_CAPS (*buffer);
4831   caps_changed = caps && caps != GST_PAD_CAPS (pad);
4832   GST_OBJECT_UNLOCK (pad);
4833
4834   /* we got a new datatype on the pad, see if it can handle it */
4835   if (G_UNLIKELY (caps_changed)) {
4836     GST_DEBUG_OBJECT (pad, "caps changed to %p %" GST_PTR_FORMAT, caps, caps);
4837     if (G_UNLIKELY (!gst_pad_configure_sink (pad, caps)))
4838       goto not_negotiated;
4839   }
4840   return ret;
4841
4842   /* ERROR recovery here */
4843 not_connected:
4844   {
4845     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4846         "pulling range, but it was not linked");
4847     GST_OBJECT_UNLOCK (pad);
4848     return GST_FLOW_NOT_LINKED;
4849   }
4850 pull_range_failed:
4851   {
4852     *buffer = NULL;
4853     GST_CAT_LEVEL_LOG (GST_CAT_SCHEDULING,
4854         (ret >= GST_FLOW_UNEXPECTED) ? GST_LEVEL_INFO : GST_LEVEL_WARNING,
4855         pad, "pullrange failed, flow: %s", gst_flow_get_name (ret));
4856     return ret;
4857   }
4858 dropping:
4859   {
4860     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4861         "Dropping data after FALSE probe return");
4862     gst_buffer_unref (*buffer);
4863     *buffer = NULL;
4864     return GST_FLOW_UNEXPECTED;
4865   }
4866 not_negotiated:
4867   {
4868     gst_buffer_unref (*buffer);
4869     *buffer = NULL;
4870     GST_CAT_WARNING_OBJECT (GST_CAT_SCHEDULING, pad,
4871         "pullrange returned buffer of different caps");
4872     return GST_FLOW_NOT_NEGOTIATED;
4873   }
4874 }
4875
4876 /**
4877  * gst_pad_push_event:
4878  * @pad: a #GstPad to push the event to.
4879  * @event: the #GstEvent to send to the pad.
4880  *
4881  * Sends the event to the peer of the given pad. This function is
4882  * mainly used by elements to send events to their peer
4883  * elements.
4884  *
4885  * This function takes owership of the provided event so you should
4886  * gst_event_ref() it if you want to reuse the event after this call.
4887  *
4888  * Returns: TRUE if the event was handled.
4889  *
4890  * MT safe.
4891  */
4892 gboolean
4893 gst_pad_push_event (GstPad * pad, GstEvent * event)
4894 {
4895   GstPad *peerpad;
4896   gboolean result;
4897
4898   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
4899   g_return_val_if_fail (event != NULL, FALSE);
4900   g_return_val_if_fail (GST_IS_EVENT (event), FALSE);
4901
4902   GST_LOG_OBJECT (pad, "event: %s", GST_EVENT_TYPE_NAME (event));
4903
4904   GST_OBJECT_LOCK (pad);
4905
4906   /* Two checks to be made:
4907    * . (un)set the FLUSHING flag for flushing events,
4908    * . handle pad blocking */
4909   switch (GST_EVENT_TYPE (event)) {
4910     case GST_EVENT_FLUSH_START:
4911       GST_PAD_SET_FLUSHING (pad);
4912
4913       if (G_UNLIKELY (GST_PAD_IS_BLOCKED (pad))) {
4914         /* flush start will have set the FLUSHING flag and will then
4915          * unlock all threads doing a GCond wait on the blocking pad. This
4916          * will typically unblock the STREAMING thread blocked on a pad. */
4917         GST_LOG_OBJECT (pad, "Pad is blocked, not forwarding flush-start, "
4918             "doing block signal.");
4919         GST_PAD_BLOCK_BROADCAST (pad);
4920         goto flushed;
4921       }
4922       break;
4923     case GST_EVENT_FLUSH_STOP:
4924       GST_PAD_UNSET_FLUSHING (pad);
4925
4926       /* if we are blocked, flush away the FLUSH_STOP event */
4927       if (G_UNLIKELY (GST_PAD_IS_BLOCKED (pad))) {
4928         GST_LOG_OBJECT (pad, "Pad is blocked, not forwarding flush-stop");
4929         goto flushed;
4930       }
4931       break;
4932     default:
4933       while (G_UNLIKELY (GST_PAD_IS_BLOCKED (pad))) {
4934         /* block the event as long as the pad is blocked */
4935         if (handle_pad_block (pad) != GST_FLOW_OK)
4936           goto flushed;
4937       }
4938       break;
4939   }
4940
4941   if (G_UNLIKELY (GST_PAD_DO_EVENT_SIGNALS (pad) > 0)) {
4942     GST_OBJECT_UNLOCK (pad);
4943
4944     if (!gst_pad_emit_have_data_signal (pad, GST_MINI_OBJECT (event)))
4945       goto dropping;
4946
4947     GST_OBJECT_LOCK (pad);
4948   }
4949   peerpad = GST_PAD_PEER (pad);
4950   if (peerpad == NULL)
4951     goto not_linked;
4952
4953   GST_LOG_OBJECT (pad, "sending event %s to peerpad %" GST_PTR_FORMAT,
4954       GST_EVENT_TYPE_NAME (event), peerpad);
4955   gst_object_ref (peerpad);
4956   GST_OBJECT_UNLOCK (pad);
4957
4958   result = gst_pad_send_event (peerpad, event);
4959
4960   /* Note: we gave away ownership of the event at this point */
4961   GST_LOG_OBJECT (pad, "sent event to peerpad %" GST_PTR_FORMAT ", result %d",
4962       peerpad, result);
4963   gst_object_unref (peerpad);
4964
4965   return result;
4966
4967   /* ERROR handling */
4968 dropping:
4969   {
4970     GST_DEBUG_OBJECT (pad, "Dropping event after FALSE probe return");
4971     gst_event_unref (event);
4972     return FALSE;
4973   }
4974 not_linked:
4975   {
4976     GST_DEBUG_OBJECT (pad, "Dropping event because pad is not linked");
4977     gst_event_unref (event);
4978     GST_OBJECT_UNLOCK (pad);
4979     return FALSE;
4980   }
4981 flushed:
4982   {
4983     GST_DEBUG_OBJECT (pad,
4984         "Not forwarding event since we're flushing and blocking");
4985     gst_event_unref (event);
4986     GST_OBJECT_UNLOCK (pad);
4987     return TRUE;
4988   }
4989 }
4990
4991 /**
4992  * gst_pad_send_event:
4993  * @pad: a #GstPad to send the event to.
4994  * @event: the #GstEvent to send to the pad.
4995  *
4996  * Sends the event to the pad. This function can be used
4997  * by applications to send events in the pipeline.
4998  *
4999  * If @pad is a source pad, @event should be an upstream event. If @pad is a
5000  * sink pad, @event should be a downstream event. For example, you would not
5001  * send a #GST_EVENT_EOS on a src pad; EOS events only propagate downstream.
5002  * Furthermore, some downstream events have to be serialized with data flow,
5003  * like EOS, while some can travel out-of-band, like #GST_EVENT_FLUSH_START. If
5004  * the event needs to be serialized with data flow, this function will take the
5005  * pad's stream lock while calling its event function.
5006  *
5007  * To find out whether an event type is upstream, downstream, or downstream and
5008  * serialized, see #GstEventTypeFlags, gst_event_type_get_flags(),
5009  * #GST_EVENT_IS_UPSTREAM, #GST_EVENT_IS_DOWNSTREAM, and
5010  * #GST_EVENT_IS_SERIALIZED. Note that in practice that an application or
5011  * plugin doesn't need to bother itself with this information; the core handles
5012  * all necessary locks and checks.
5013  *
5014  * This function takes owership of the provided event so you should
5015  * gst_event_ref() it if you want to reuse the event after this call.
5016  *
5017  * Returns: TRUE if the event was handled.
5018  */
5019 gboolean
5020 gst_pad_send_event (GstPad * pad, GstEvent * event)
5021 {
5022   gboolean result = FALSE;
5023   GstPadEventFunction eventfunc;
5024   gboolean serialized, need_unlock = FALSE;
5025
5026   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5027   g_return_val_if_fail (event != NULL, FALSE);
5028
5029   GST_OBJECT_LOCK (pad);
5030   if (GST_PAD_IS_SINK (pad)) {
5031     if (G_UNLIKELY (!GST_EVENT_IS_DOWNSTREAM (event)))
5032       goto wrong_direction;
5033     serialized = GST_EVENT_IS_SERIALIZED (event);
5034   } else if (GST_PAD_IS_SRC (pad)) {
5035     if (G_UNLIKELY (!GST_EVENT_IS_UPSTREAM (event)))
5036       goto wrong_direction;
5037     /* events on srcpad never are serialized */
5038     serialized = FALSE;
5039   } else
5040     goto unknown_direction;
5041
5042   if (G_UNLIKELY (GST_EVENT_SRC (event) == NULL)) {
5043     GST_LOG_OBJECT (pad, "event had no source, setting pad as event source");
5044     GST_EVENT_SRC (event) = gst_object_ref (pad);
5045   }
5046
5047   /* pad signals */
5048   if (G_UNLIKELY (GST_PAD_DO_EVENT_SIGNALS (pad) > 0)) {
5049     GST_OBJECT_UNLOCK (pad);
5050
5051     if (!gst_pad_emit_have_data_signal (pad, GST_MINI_OBJECT_CAST (event)))
5052       goto dropping;
5053
5054     GST_OBJECT_LOCK (pad);
5055   }
5056
5057   switch (GST_EVENT_TYPE (event)) {
5058     case GST_EVENT_FLUSH_START:
5059       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad,
5060           "have event type %d (FLUSH_START)", GST_EVENT_TYPE (event));
5061
5062       /* can't even accept a flush begin event when flushing */
5063       if (GST_PAD_IS_FLUSHING (pad))
5064         goto flushing;
5065       GST_PAD_SET_FLUSHING (pad);
5066       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad, "set flush flag");
5067       break;
5068     case GST_EVENT_FLUSH_STOP:
5069       GST_PAD_UNSET_FLUSHING (pad);
5070       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad, "cleared flush flag");
5071       GST_OBJECT_UNLOCK (pad);
5072       /* grab stream lock */
5073       GST_PAD_STREAM_LOCK (pad);
5074       need_unlock = TRUE;
5075       GST_OBJECT_LOCK (pad);
5076       break;
5077     default:
5078       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad, "have event type %s",
5079           GST_EVENT_TYPE_NAME (event));
5080
5081       /* make this a little faster, no point in grabbing the lock
5082        * if the pad is allready flushing. */
5083       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
5084         goto flushing;
5085
5086       if (serialized) {
5087         /* lock order: STREAM_LOCK, LOCK, recheck flushing. */
5088         GST_OBJECT_UNLOCK (pad);
5089         GST_PAD_STREAM_LOCK (pad);
5090         need_unlock = TRUE;
5091         GST_OBJECT_LOCK (pad);
5092         if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
5093           goto flushing;
5094       }
5095       break;
5096   }
5097   if (G_UNLIKELY ((eventfunc = GST_PAD_EVENTFUNC (pad)) == NULL))
5098     goto no_function;
5099
5100   GST_OBJECT_UNLOCK (pad);
5101
5102   result = eventfunc (pad, event);
5103
5104   if (need_unlock)
5105     GST_PAD_STREAM_UNLOCK (pad);
5106
5107   GST_DEBUG_OBJECT (pad, "sent event, result %d", result);
5108
5109   return result;
5110
5111   /* ERROR handling */
5112 wrong_direction:
5113   {
5114     g_warning ("pad %s:%s sending %s event in wrong direction",
5115         GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE_NAME (event));
5116     GST_OBJECT_UNLOCK (pad);
5117     gst_event_unref (event);
5118     return FALSE;
5119   }
5120 unknown_direction:
5121   {
5122     g_warning ("pad %s:%s has invalid direction", GST_DEBUG_PAD_NAME (pad));
5123     GST_OBJECT_UNLOCK (pad);
5124     gst_event_unref (event);
5125     return FALSE;
5126   }
5127 no_function:
5128   {
5129     g_warning ("pad %s:%s has no event handler, file a bug.",
5130         GST_DEBUG_PAD_NAME (pad));
5131     GST_OBJECT_UNLOCK (pad);
5132     if (need_unlock)
5133       GST_PAD_STREAM_UNLOCK (pad);
5134     gst_event_unref (event);
5135     return FALSE;
5136   }
5137 flushing:
5138   {
5139     GST_OBJECT_UNLOCK (pad);
5140     if (need_unlock)
5141       GST_PAD_STREAM_UNLOCK (pad);
5142     GST_CAT_INFO_OBJECT (GST_CAT_EVENT, pad,
5143         "Received event on flushing pad. Discarding");
5144     gst_event_unref (event);
5145     return FALSE;
5146   }
5147 dropping:
5148   {
5149     GST_DEBUG_OBJECT (pad, "Dropping event after FALSE probe return");
5150     gst_event_unref (event);
5151     return FALSE;
5152   }
5153 }
5154
5155 /**
5156  * gst_pad_set_element_private:
5157  * @pad: the #GstPad to set the private data of.
5158  * @priv: The private data to attach to the pad.
5159  *
5160  * Set the given private data gpointer on the pad.
5161  * This function can only be used by the element that owns the pad.
5162  * No locking is performed in this function.
5163  */
5164 void
5165 gst_pad_set_element_private (GstPad * pad, gpointer priv)
5166 {
5167   pad->element_private = priv;
5168 }
5169
5170 /**
5171  * gst_pad_get_element_private:
5172  * @pad: the #GstPad to get the private data of.
5173  *
5174  * Gets the private data of a pad.
5175  * No locking is performed in this function.
5176  *
5177  * Returns: a #gpointer to the private data.
5178  */
5179 gpointer
5180 gst_pad_get_element_private (GstPad * pad)
5181 {
5182   return pad->element_private;
5183 }
5184
5185 static void
5186 do_stream_status (GstPad * pad, GstStreamStatusType type,
5187     GThread * thread, GstTask * task)
5188 {
5189   GstElement *parent;
5190
5191   GST_DEBUG_OBJECT (pad, "doing stream-status %d", type);
5192
5193   if ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (pad)))) {
5194     if (GST_IS_ELEMENT (parent)) {
5195       GstMessage *message;
5196       GValue value = { 0 };
5197
5198       if (type == GST_STREAM_STATUS_TYPE_ENTER) {
5199         gchar *tname, *ename, *pname;
5200
5201         /* create a good task name */
5202         ename = gst_element_get_name (parent);
5203         pname = gst_pad_get_name (pad);
5204         tname = g_strdup_printf ("%s:%s", ename, pname);
5205         g_free (ename);
5206         g_free (pname);
5207
5208         gst_object_set_name (GST_OBJECT_CAST (task), tname);
5209         g_free (tname);
5210       }
5211
5212       message = gst_message_new_stream_status (GST_OBJECT_CAST (pad),
5213           type, parent);
5214
5215       g_value_init (&value, GST_TYPE_TASK);
5216       g_value_set_object (&value, task);
5217       gst_message_set_stream_status_object (message, &value);
5218       g_value_unset (&value);
5219
5220       GST_DEBUG_OBJECT (pad, "posting stream-status %d", type);
5221       gst_element_post_message (parent, message);
5222     }
5223     gst_object_unref (parent);
5224   }
5225 }
5226
5227 static void
5228 pad_enter_thread (GstTask * task, GThread * thread, gpointer user_data)
5229 {
5230   do_stream_status (GST_PAD_CAST (user_data), GST_STREAM_STATUS_TYPE_ENTER,
5231       thread, task);
5232 }
5233
5234 static void
5235 pad_leave_thread (GstTask * task, GThread * thread, gpointer user_data)
5236 {
5237   do_stream_status (GST_PAD_CAST (user_data), GST_STREAM_STATUS_TYPE_LEAVE,
5238       thread, task);
5239 }
5240
5241 static GstTaskThreadCallbacks thr_callbacks = {
5242   pad_enter_thread,
5243   pad_leave_thread,
5244 };
5245
5246 /**
5247  * gst_pad_start_task:
5248  * @pad: the #GstPad to start the task of
5249  * @func: the task function to call
5250  * @data: data passed to the task function
5251  *
5252  * Starts a task that repeatedly calls @func with @data. This function
5253  * is mostly used in pad activation functions to start the dataflow.
5254  * The #GST_PAD_STREAM_LOCK of @pad will automatically be acquired
5255  * before @func is called.
5256  *
5257  * Returns: a %TRUE if the task could be started.
5258  */
5259 gboolean
5260 gst_pad_start_task (GstPad * pad, GstTaskFunction func, gpointer data)
5261 {
5262   GstTask *task;
5263   gboolean res;
5264
5265   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5266   g_return_val_if_fail (func != NULL, FALSE);
5267
5268   GST_DEBUG_OBJECT (pad, "start task");
5269
5270   GST_OBJECT_LOCK (pad);
5271   task = GST_PAD_TASK (pad);
5272   if (task == NULL) {
5273     task = gst_task_create (func, data);
5274     gst_task_set_lock (task, GST_PAD_GET_STREAM_LOCK (pad));
5275     gst_task_set_thread_callbacks (task, &thr_callbacks, pad, NULL);
5276     GST_DEBUG_OBJECT (pad, "created task");
5277     GST_PAD_TASK (pad) = task;
5278     gst_object_ref (task);
5279     /* release lock to post the message */
5280     GST_OBJECT_UNLOCK (pad);
5281
5282     do_stream_status (pad, GST_STREAM_STATUS_TYPE_CREATE, NULL, task);
5283
5284     gst_object_unref (task);
5285
5286     GST_OBJECT_LOCK (pad);
5287     /* nobody else is supposed to have changed the pad now */
5288     if (GST_PAD_TASK (pad) != task)
5289       goto concurrent_stop;
5290   }
5291   res = gst_task_set_state (task, GST_TASK_STARTED);
5292   GST_OBJECT_UNLOCK (pad);
5293
5294   return res;
5295
5296   /* ERRORS */
5297 concurrent_stop:
5298   {
5299     GST_OBJECT_UNLOCK (pad);
5300     return TRUE;
5301   }
5302 }
5303
5304 /**
5305  * gst_pad_pause_task:
5306  * @pad: the #GstPad to pause the task of
5307  *
5308  * Pause the task of @pad. This function will also wait until the
5309  * function executed by the task is finished if this function is not
5310  * called from the task function.
5311  *
5312  * Returns: a TRUE if the task could be paused or FALSE when the pad
5313  * has no task.
5314  */
5315 gboolean
5316 gst_pad_pause_task (GstPad * pad)
5317 {
5318   GstTask *task;
5319   gboolean res;
5320
5321   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5322
5323   GST_DEBUG_OBJECT (pad, "pause task");
5324
5325   GST_OBJECT_LOCK (pad);
5326   task = GST_PAD_TASK (pad);
5327   if (task == NULL)
5328     goto no_task;
5329   res = gst_task_set_state (task, GST_TASK_PAUSED);
5330   GST_OBJECT_UNLOCK (pad);
5331
5332   /* wait for task function to finish, this lock is recursive so it does nothing
5333    * when the pause is called from the task itself */
5334   GST_PAD_STREAM_LOCK (pad);
5335   GST_PAD_STREAM_UNLOCK (pad);
5336
5337   return res;
5338
5339 no_task:
5340   {
5341     GST_DEBUG_OBJECT (pad, "pad has no task");
5342     GST_OBJECT_UNLOCK (pad);
5343     return FALSE;
5344   }
5345 }
5346
5347 /**
5348  * gst_pad_stop_task:
5349  * @pad: the #GstPad to stop the task of
5350  *
5351  * Stop the task of @pad. This function will also make sure that the
5352  * function executed by the task will effectively stop if not called
5353  * from the GstTaskFunction.
5354  *
5355  * This function will deadlock if called from the GstTaskFunction of
5356  * the task. Use gst_task_pause() instead.
5357  *
5358  * Regardless of whether the pad has a task, the stream lock is acquired and
5359  * released so as to ensure that streaming through this pad has finished.
5360  *
5361  * Returns: a TRUE if the task could be stopped or FALSE on error.
5362  */
5363 gboolean
5364 gst_pad_stop_task (GstPad * pad)
5365 {
5366   GstTask *task;
5367   gboolean res;
5368
5369   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5370
5371   GST_DEBUG_OBJECT (pad, "stop task");
5372
5373   GST_OBJECT_LOCK (pad);
5374   task = GST_PAD_TASK (pad);
5375   if (task == NULL)
5376     goto no_task;
5377   GST_PAD_TASK (pad) = NULL;
5378   res = gst_task_set_state (task, GST_TASK_STOPPED);
5379   GST_OBJECT_UNLOCK (pad);
5380
5381   GST_PAD_STREAM_LOCK (pad);
5382   GST_PAD_STREAM_UNLOCK (pad);
5383
5384   if (!gst_task_join (task))
5385     goto join_failed;
5386
5387   gst_object_unref (task);
5388
5389   return res;
5390
5391 no_task:
5392   {
5393     GST_DEBUG_OBJECT (pad, "no task");
5394     GST_OBJECT_UNLOCK (pad);
5395
5396     GST_PAD_STREAM_LOCK (pad);
5397     GST_PAD_STREAM_UNLOCK (pad);
5398
5399     /* this is not an error */
5400     return TRUE;
5401   }
5402 join_failed:
5403   {
5404     /* this is bad, possibly the application tried to join the task from
5405      * the task's thread. We install the task again so that it will be stopped
5406      * again from the right thread next time hopefully. */
5407     GST_OBJECT_LOCK (pad);
5408     GST_DEBUG_OBJECT (pad, "join failed");
5409     /* we can only install this task if there was no other task */
5410     if (GST_PAD_TASK (pad) == NULL)
5411       GST_PAD_TASK (pad) = task;
5412     GST_OBJECT_UNLOCK (pad);
5413
5414     return FALSE;
5415   }
5416 }