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_query_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   /* FILL ME */
  84   LAST_SIGNAL
  85 };
  86
  87 enum
  88 {
  89   PAD_PROP_0,
  90   PAD_PROP_CAPS,
  91   PAD_PROP_DIRECTION,
  92   PAD_PROP_TEMPLATE,
  93   /* FILL ME */
  94 };
  95
  96 #define GST_PAD_GET_PRIVATE(obj)  \
  97    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_PAD, GstPadPrivate))
  98
  99 /* we have a pending and an active event on the pad. On source pads only the
 100  * active event is used. On sinkpads, events are copied to the pending entry and
 101  * moved to the active event when the eventfunc returned TRUE. */
 102 typedef struct
 103 {
 104   gboolean received;
 105   GstEvent *event;
 106 } PadEvent;
 107
 108 struct _GstPadPrivate
 109 {
 110   guint events_cookie;
 111   GArray *events;
 112
 113   gint using;
 114   guint probe_list_cookie;
 115   guint probe_cookie;
 116 };
 117
 118 typedef struct
 119 {
 120   GHook hook;
 121   guint cookie;
 122 } GstProbe;
 123
 124 #define PROBE_COOKIE(h) (((GstProbe *)(h))->cookie)
 125
 126 typedef struct
 127 {
 128   GstPad *pad;
 129   GstPadProbeInfo *info;
 130   gboolean dropped;
 131   gboolean pass;
 132   gboolean marshalled;
 133   guint cookie;
 134 } ProbeMarshall;
 135
 136 static void gst_pad_dispose (GObject * object);
 137 static void gst_pad_finalize (GObject * object);
 138 static void gst_pad_set_property (GObject * object, guint prop_id,
 139     const GValue * value, GParamSpec * pspec);
 140 static void gst_pad_get_property (GObject * object, guint prop_id,
 141     GValue * value, GParamSpec * pspec);
 142
 143 static void gst_pad_set_pad_template (GstPad * pad, GstPadTemplate * templ);
 144 static gboolean gst_pad_activate_default (GstPad * pad, GstObject * parent);
 145 static GstFlowReturn gst_pad_chain_list_default (GstPad * pad,
 146     GstObject * parent, GstBufferList * list);
 147
 148 static GstFlowReturn gst_pad_send_event_unchecked (GstPad * pad,
 149     GstEvent * event, GstPadProbeType type);
 150 static GstFlowReturn gst_pad_push_event_unchecked (GstPad * pad,
 151     GstEvent * event, GstPadProbeType type, gboolean * stored);
 152
 153 static guint gst_pad_signals[LAST_SIGNAL] = { 0 };
 154
 155 static GParamSpec *pspec_caps = NULL;
 156
 157 /* quarks for probe signals */
 158 static GQuark buffer_quark;
 159 static GQuark buffer_list_quark;
 160 static GQuark event_quark;
 161
 162 typedef struct
 163 {
 164   const gint ret;
 165   const gchar *name;
 166   GQuark quark;
 167 } GstFlowQuarks;
 168
 169 static GstFlowQuarks flow_quarks[] = {
 170   {GST_FLOW_CUSTOM_SUCCESS, "custom-success", 0},
 171   {GST_FLOW_OK, "ok", 0},
 172   {GST_FLOW_NOT_LINKED, "not-linked", 0},
 173   {GST_FLOW_WRONG_STATE, "wrong-state", 0},
 174   {GST_FLOW_EOS, "eos", 0},
 175   {GST_FLOW_NOT_NEGOTIATED, "not-negotiated", 0},
 176   {GST_FLOW_ERROR, "error", 0},
 177   {GST_FLOW_NOT_SUPPORTED, "not-supported", 0},
 178   {GST_FLOW_CUSTOM_ERROR, "custom-error", 0}
 179 };
 180
 181 /**
 182  * gst_flow_get_name:
 183  * @ret: a #GstFlowReturn to get the name of.
 184  *
 185  * Gets a string representing the given flow return.
 186  *
 187  * Returns: a static string with the name of the flow return.
 188  */
 189 const gchar *
 190 gst_flow_get_name (GstFlowReturn ret)
 191 {
 192   gint i;
 193
 194   ret = CLAMP (ret, GST_FLOW_CUSTOM_ERROR, GST_FLOW_CUSTOM_SUCCESS);
 195
 196   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {
 197     if (ret == flow_quarks[i].ret)
 198       return flow_quarks[i].name;
 199   }
 200   return "unknown";
 201 }
 202
 203 /**
 204  * gst_flow_to_quark:
 205  * @ret: a #GstFlowReturn to get the quark of.
 206  *
 207  * Get the unique quark for the given GstFlowReturn.
 208  *
 209  * Returns: the quark associated with the flow return or 0 if an
 210  * invalid return was specified.
 211  */
 212 GQuark
 213 gst_flow_to_quark (GstFlowReturn ret)
 214 {
 215   gint i;
 216
 217   ret = CLAMP (ret, GST_FLOW_CUSTOM_ERROR, GST_FLOW_CUSTOM_SUCCESS);
 218
 219   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {
 220     if (ret == flow_quarks[i].ret)
 221       return flow_quarks[i].quark;
 222   }
 223   return 0;
 224 }
 225
 226 #define _do_init \
 227 { \
 228   gint i; \
 229   \
 230   buffer_quark = g_quark_from_static_string ("buffer"); \
 231   buffer_list_quark = g_quark_from_static_string ("bufferlist"); \
 232   event_quark = g_quark_from_static_string ("event"); \
 233   \
 234   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {                    \
 235     flow_quarks[i].quark = g_quark_from_static_string (flow_quarks[i].name); \
 236   } \
 237   \
 238   GST_DEBUG_CATEGORY_INIT (debug_dataflow, "GST_DATAFLOW", \
 239       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "dataflow inside pads"); \
 240 }
 241
 242 #define gst_pad_parent_class parent_class
 243 G_DEFINE_TYPE_WITH_CODE (GstPad, gst_pad, GST_TYPE_OBJECT, _do_init);
 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   gobject_class->dispose = gst_pad_dispose;
 257   gobject_class->finalize = gst_pad_finalize;
 258   gobject_class->set_property = gst_pad_set_property;
 259   gobject_class->get_property = gst_pad_get_property;
 260
 261   /**
 262    * GstPad::linked:
 263    * @pad: the pad that emitted the signal
 264    * @peer: the peer pad that has been connected
 265    *
 266    * Signals that a pad has been linked to the peer pad.
 267    */
 268   gst_pad_signals[PAD_LINKED] =
 269       g_signal_new ("linked", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 270       G_STRUCT_OFFSET (GstPadClass, linked), NULL, NULL,
 271       gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_PAD);
 272   /**
 273    * GstPad::unlinked:
 274    * @pad: the pad that emitted the signal
 275    * @peer: the peer pad that has been disconnected
 276    *
 277    * Signals that a pad has been unlinked from the peer pad.
 278    */
 279   gst_pad_signals[PAD_UNLINKED] =
 280       g_signal_new ("unlinked", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 281       G_STRUCT_OFFSET (GstPadClass, unlinked), NULL, NULL,
 282       gst_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_PAD);
 283
 284   pspec_caps = g_param_spec_boxed ("caps", "Caps",
 285       "The capabilities of the pad", GST_TYPE_CAPS,
 286       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 287   g_object_class_install_property (gobject_class, PAD_PROP_CAPS, pspec_caps);
 288
 289   g_object_class_install_property (gobject_class, PAD_PROP_DIRECTION,
 290       g_param_spec_enum ("direction", "Direction", "The direction of the pad",
 291           GST_TYPE_PAD_DIRECTION, GST_PAD_UNKNOWN,
 292           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
 293
 294   /* FIXME, Make G_PARAM_CONSTRUCT_ONLY when we fix ghostpads. */
 295   g_object_class_install_property (gobject_class, PAD_PROP_TEMPLATE,
 296       g_param_spec_object ("template", "Template",
 297           "The GstPadTemplate of this pad", GST_TYPE_PAD_TEMPLATE,
 298           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 299
 300   gstobject_class->path_string_separator = ".";
 301
 302   /* Register common function pointer descriptions */
 303   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_activate_default);
 304   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_event_default);
 305   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_query_default);
 306   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_iterate_internal_links_default);
 307   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_chain_list_default);
 308 }
 309
 310 static void
 311 gst_pad_init (GstPad * pad)
 312 {
 313   pad->priv = GST_PAD_GET_PRIVATE (pad);
 314
 315   GST_PAD_DIRECTION (pad) = GST_PAD_UNKNOWN;
 316
 317   GST_PAD_ACTIVATEFUNC (pad) = gst_pad_activate_default;
 318   GST_PAD_EVENTFUNC (pad) = gst_pad_event_default;
 319   GST_PAD_QUERYFUNC (pad) = gst_pad_query_default;
 320   GST_PAD_ITERINTLINKFUNC (pad) = gst_pad_iterate_internal_links_default;
 321   GST_PAD_CHAINLISTFUNC (pad) = gst_pad_chain_list_default;
 322
 323   GST_PAD_SET_FLUSHING (pad);
 324
 325   g_rec_mutex_init (&pad->stream_rec_lock);
 326
 327   g_cond_init (&pad->block_cond);
 328
 329   g_hook_list_init (&pad->probes, sizeof (GstProbe));
 330
 331   pad->priv->events = g_array_sized_new (FALSE, TRUE, sizeof (PadEvent), 16);
 332 }
 333
 334 /* called when setting the pad inactive. It removes all sticky events from
 335  * the pad */
 336 static void
 337 remove_events (GstPad * pad)
 338 {
 339   guint i, len;
 340   GArray *events;
 341
 342   events = pad->priv->events;
 343
 344   len = events->len;
 345   for (i = 0; i < len; i++) {
 346     PadEvent *ev = &g_array_index (events, PadEvent, i);
 347     gst_event_unref (ev->event);
 348   }
 349   GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PENDING_EVENTS);
 350   g_array_set_size (events, 0);
 351   pad->priv->events_cookie++;
 352 }
 353
 354 static PadEvent *
 355 find_event_by_type (GstPad * pad, GstEventType type, guint idx)
 356 {
 357   guint i, len;
 358   GArray *events;
 359   PadEvent *ev;
 360
 361   events = pad->priv->events;
 362   len = events->len;
 363
 364   for (i = 0; i < len; i++) {
 365     ev = &g_array_index (events, PadEvent, i);
 366     if (ev->event == NULL)
 367       continue;
 368
 369     if (GST_EVENT_TYPE (ev->event) == type) {
 370       if (idx == 0)
 371         goto found;
 372       idx--;
 373     }
 374   }
 375   ev = NULL;
 376 found:
 377   return ev;
 378 }
 379
 380 static PadEvent *
 381 find_event (GstPad * pad, GstEvent * event)
 382 {
 383   guint i, len;
 384   GArray *events;
 385   PadEvent *ev;
 386
 387   events = pad->priv->events;
 388   len = events->len;
 389
 390   for (i = 0; i < len; i++) {
 391     ev = &g_array_index (events, PadEvent, i);
 392     if (event == ev->event)
 393       goto found;
 394   }
 395   ev = NULL;
 396 found:
 397   return ev;
 398 }
 399
 400 static void
 401 remove_event_by_type (GstPad * pad, GstEventType type)
 402 {
 403   guint i, len;
 404   GArray *events;
 405   PadEvent *ev;
 406
 407   events = pad->priv->events;
 408   len = events->len;
 409
 410   i = 0;
 411   while (i < len) {
 412     ev = &g_array_index (events, PadEvent, i);
 413     if (ev->event == NULL)
 414       goto next;
 415
 416     if (GST_EVENT_TYPE (ev->event) != type)
 417       goto next;
 418
 419     gst_event_unref (ev->event);
 420     g_array_remove_index (events, i);
 421     len--;
 422     pad->priv->events_cookie++;
 423     continue;
 424
 425   next:
 426     i++;
 427   }
 428 }
 429
 430 static void
 431 schedule_events (GstPad * srcpad, GstPad * sinkpad)
 432 {
 433   gint i, len;
 434   GArray *events;
 435   PadEvent *ev;
 436   gboolean pending = FALSE;
 437
 438   events = srcpad->priv->events;
 439   len = events->len;
 440
 441   for (i = 0; i < len; i++) {
 442     ev = &g_array_index (events, PadEvent, i);
 443     if (ev->event == NULL)
 444       continue;
 445
 446     if (sinkpad == NULL || !find_event (sinkpad, ev->event)) {
 447       ev->received = FALSE;
 448       pending = TRUE;
 449     }
 450   }
 451   if (pending)
 452     GST_OBJECT_FLAG_SET (srcpad, GST_PAD_FLAG_PENDING_EVENTS);
 453 }
 454
 455 typedef gboolean (*PadEventFunction) (GstPad * pad, PadEvent * ev,
 456     gpointer user_data);
 457
 458 static void
 459 events_foreach (GstPad * pad, PadEventFunction func, gpointer user_data)
 460 {
 461   guint i, len;
 462   GArray *events;
 463   gboolean ret;
 464   guint cookie;
 465
 466   events = pad->priv->events;
 467
 468 restart:
 469   cookie = pad->priv->events_cookie;
 470   i = 0;
 471   len = events->len;
 472   while (i < len) {
 473     PadEvent *ev, ev_ret;
 474
 475     ev = &g_array_index (events, PadEvent, i);
 476     if (G_UNLIKELY (ev->event == NULL))
 477       goto next;
 478
 479     /* take aditional ref, func might release the lock */
 480     ev_ret.event = gst_event_ref (ev->event);
 481     ev_ret.received = ev->received;
 482
 483     ret = func (pad, &ev_ret, user_data);
 484
 485     /* recheck the cookie, lock might have been released and the list could have
 486      * changed */
 487     if (G_UNLIKELY (cookie != pad->priv->events_cookie)) {
 488       if (G_LIKELY (ev_ret.event))
 489         gst_event_unref (ev_ret.event);
 490       goto restart;
 491     }
 492
 493     /* if the event changed, we need to do something */
 494     if (G_UNLIKELY (ev->event != ev_ret.event)) {
 495       if (G_UNLIKELY (ev_ret.event == NULL)) {
 496         /* function unreffed and set the event to NULL, remove it */
 497         g_array_remove_index (events, i);
 498         len--;
 499         cookie = ++pad->priv->events_cookie;
 500         continue;
 501       } else {
 502         /* function gave a new event for us */
 503         gst_event_take (&ev->event, ev_ret.event);
 504       }
 505     } else {
 506       /* just unref, nothing changed */
 507       gst_event_unref (ev_ret.event);
 508     }
 509     if (!ret)
 510       break;
 511   next:
 512     i++;
 513   }
 514 }
 515
 516 /* should be called with LOCK */
 517 static GstEvent *
 518 apply_pad_offset (GstPad * pad, GstEvent * event)
 519 {
 520   /* check if we need to adjust the segment */
 521   if (pad->offset != 0) {
 522     GstSegment segment;
 523
 524     /* copy segment values */
 525     gst_event_copy_segment (event, &segment);
 526     gst_event_unref (event);
 527
 528     /* adjust and make a new event with the offset applied */
 529     segment.base += pad->offset;
 530     event = gst_event_new_segment (&segment);
 531   }
 532   return event;
 533 }
 534
 535 /* should be called with the OBJECT_LOCK */
 536 static GstCaps *
 537 get_pad_caps (GstPad * pad)
 538 {
 539   GstCaps *caps = NULL;
 540   PadEvent *ev;
 541
 542   ev = find_event_by_type (pad, GST_EVENT_CAPS, 0);
 543   if (ev && ev->event)
 544     gst_event_parse_caps (ev->event, &caps);
 545
 546   return caps;
 547 }
 548
 549 static void
 550 gst_pad_dispose (GObject * object)
 551 {
 552   GstPad *pad = GST_PAD_CAST (object);
 553   GstPad *peer;
 554
 555   GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, pad, "dispose");
 556
 557   /* unlink the peer pad */
 558   if ((peer = gst_pad_get_peer (pad))) {
 559     /* window for MT unsafeness, someone else could unlink here
 560      * and then we call unlink with wrong pads. The unlink
 561      * function would catch this and safely return failed. */
 562     if (GST_PAD_IS_SRC (pad))
 563       gst_pad_unlink (pad, peer);
 564     else
 565       gst_pad_unlink (peer, pad);
 566
 567     gst_object_unref (peer);
 568   }
 569
 570   gst_pad_set_pad_template (pad, NULL);
 571
 572   remove_events (pad);
 573
 574   g_hook_list_clear (&pad->probes);
 575
 576   G_OBJECT_CLASS (parent_class)->dispose (object);
 577 }
 578
 579 static void
 580 gst_pad_finalize (GObject * object)
 581 {
 582   GstPad *pad = GST_PAD_CAST (object);
 583   GstTask *task;
 584
 585   /* in case the task is still around, clean it up */
 586   if ((task = GST_PAD_TASK (pad))) {
 587     gst_task_join (task);
 588     GST_PAD_TASK (pad) = NULL;
 589     gst_object_unref (task);
 590   }
 591
 592   if (pad->activatenotify)
 593     pad->activatenotify (pad->activatedata);
 594   if (pad->activatemodenotify)
 595     pad->activatemodenotify (pad->activatemodedata);
 596   if (pad->linknotify)
 597     pad->linknotify (pad->linkdata);
 598   if (pad->unlinknotify)
 599     pad->unlinknotify (pad->unlinkdata);
 600   if (pad->chainnotify)
 601     pad->chainnotify (pad->chaindata);
 602   if (pad->chainlistnotify)
 603     pad->chainlistnotify (pad->chainlistdata);
 604   if (pad->getrangenotify)
 605     pad->getrangenotify (pad->getrangedata);
 606   if (pad->eventnotify)
 607     pad->eventnotify (pad->eventdata);
 608   if (pad->querynotify)
 609     pad->querynotify (pad->querydata);
 610   if (pad->iterintlinknotify)
 611     pad->iterintlinknotify (pad->iterintlinkdata);
 612
 613   g_rec_mutex_clear (&pad->stream_rec_lock);
 614   g_cond_clear (&pad->block_cond);
 615   g_array_free (pad->priv->events, TRUE);
 616
 617   G_OBJECT_CLASS (parent_class)->finalize (object);
 618 }
 619
 620 static void
 621 gst_pad_set_property (GObject * object, guint prop_id,
 622     const GValue * value, GParamSpec * pspec)
 623 {
 624   g_return_if_fail (GST_IS_PAD (object));
 625
 626   switch (prop_id) {
 627     case PAD_PROP_DIRECTION:
 628       GST_PAD_DIRECTION (object) = (GstPadDirection) g_value_get_enum (value);
 629       break;
 630     case PAD_PROP_TEMPLATE:
 631       gst_pad_set_pad_template (GST_PAD_CAST (object),
 632           (GstPadTemplate *) g_value_get_object (value));
 633       break;
 634     default:
 635       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 636       break;
 637   }
 638 }
 639
 640 static void
 641 gst_pad_get_property (GObject * object, guint prop_id,
 642     GValue * value, GParamSpec * pspec)
 643 {
 644   g_return_if_fail (GST_IS_PAD (object));
 645
 646   switch (prop_id) {
 647     case PAD_PROP_CAPS:
 648       GST_OBJECT_LOCK (object);
 649       g_value_set_boxed (value, get_pad_caps (GST_PAD_CAST (object)));
 650       GST_OBJECT_UNLOCK (object);
 651       break;
 652     case PAD_PROP_DIRECTION:
 653       g_value_set_enum (value, GST_PAD_DIRECTION (object));
 654       break;
 655     case PAD_PROP_TEMPLATE:
 656       g_value_set_object (value, GST_PAD_PAD_TEMPLATE (object));
 657       break;
 658     default:
 659       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 660       break;
 661   }
 662 }
 663
 664 /**
 665  * gst_pad_new:
 666  * @name: the name of the new pad.
 667  * @direction: the #GstPadDirection of the pad.
 668  *
 669  * Creates a new pad with the given name in the given direction.
 670  * If name is NULL, a guaranteed unique name (across all pads)
 671  * will be assigned.
 672  * This function makes a copy of the name so you can safely free the name.
 673  *
 674  * Returns: (transfer floating): a new #GstPad, or NULL in case of an error.
 675  *
 676  * MT safe.
 677  */
 678 GstPad *
 679 gst_pad_new (const gchar * name, GstPadDirection direction)
 680 {
 681   return g_object_new (GST_TYPE_PAD,
 682       "name", name, "direction", direction, NULL);
 683 }
 684
 685 /**
 686  * gst_pad_new_from_template:
 687  * @templ: the pad template to use
 688  * @name: the name of the element
 689  *
 690  * Creates a new pad with the given name from the given template.
 691  * If name is NULL, a guaranteed unique name (across all pads)
 692  * will be assigned.
 693  * This function makes a copy of the name so you can safely free the name.
 694  *
 695  * Returns: (transfer full): a new #GstPad, or NULL in case of an error.
 696  */
 697 GstPad *
 698 gst_pad_new_from_template (GstPadTemplate * templ, const gchar * name)
 699 {
 700   g_return_val_if_fail (GST_IS_PAD_TEMPLATE (templ), NULL);
 701
 702   return g_object_new (GST_TYPE_PAD,
 703       "name", name, "direction", templ->direction, "template", templ, NULL);
 704 }
 705
 706 /**
 707  * gst_pad_new_from_static_template:
 708  * @templ: the #GstStaticPadTemplate to use
 709  * @name: the name of the element
 710  *
 711  * Creates a new pad with the given name from the given static template.
 712  * If name is NULL, a guaranteed unique name (across all pads)
 713  * will be assigned.
 714  * This function makes a copy of the name so you can safely free the name.
 715  *
 716  * Returns: (transfer full): a new #GstPad, or NULL in case of an error.
 717  */
 718 GstPad *
 719 gst_pad_new_from_static_template (GstStaticPadTemplate * templ,
 720     const gchar * name)
 721 {
 722   GstPad *pad;
 723   GstPadTemplate *template;
 724
 725   template = gst_static_pad_template_get (templ);
 726   pad = gst_pad_new_from_template (template, name);
 727   gst_object_unref (template);
 728   return pad;
 729 }
 730
 731 #define ACQUIRE_PARENT(pad, parent, label)                      \
 732   G_STMT_START {                                                \
 733     if (G_LIKELY ((parent = GST_OBJECT_PARENT (pad))))          \
 734       gst_object_ref (parent);                                  \
 735     else if (G_LIKELY (GST_PAD_NEEDS_PARENT (pad)))             \
 736       goto label;                                               \
 737   } G_STMT_END
 738
 739 #define RELEASE_PARENT(parent)                                  \
 740   G_STMT_START {                                                \
 741     if (G_LIKELY (parent))                                      \
 742       gst_object_unref (parent);                                \
 743   } G_STMT_END
 744
 745 /**
 746  * gst_pad_get_direction:
 747  * @pad: a #GstPad to get the direction of.
 748  *
 749  * Gets the direction of the pad. The direction of the pad is
 750  * decided at construction time so this function does not take
 751  * the LOCK.
 752  *
 753  * Returns: the #GstPadDirection of the pad.
 754  *
 755  * MT safe.
 756  */
 757 GstPadDirection
 758 gst_pad_get_direction (GstPad * pad)
 759 {
 760   GstPadDirection result;
 761
 762   /* PAD_UNKNOWN is a little silly but we need some sort of
 763    * error return value */
 764   g_return_val_if_fail (GST_IS_PAD (pad), GST_PAD_UNKNOWN);
 765
 766   result = GST_PAD_DIRECTION (pad);
 767
 768   return result;
 769 }
 770
 771 static gboolean
 772 gst_pad_activate_default (GstPad * pad, GstObject * parent)
 773 {
 774   return gst_pad_activate_mode (pad, GST_PAD_MODE_PUSH, TRUE);
 775 }
 776
 777 static void
 778 pre_activate (GstPad * pad, GstPadMode new_mode)
 779 {
 780   switch (new_mode) {
 781     case GST_PAD_MODE_NONE:
 782       GST_OBJECT_LOCK (pad);
 783       GST_DEBUG_OBJECT (pad, "setting PAD_MODE NONE, set flushing");
 784       GST_PAD_SET_FLUSHING (pad);
 785       GST_PAD_MODE (pad) = new_mode;
 786       /* unlock blocked pads so element can resume and stop */
 787       GST_PAD_BLOCK_BROADCAST (pad);
 788       GST_OBJECT_UNLOCK (pad);
 789       break;
 790     case GST_PAD_MODE_PUSH:
 791     case GST_PAD_MODE_PULL:
 792       GST_OBJECT_LOCK (pad);
 793       GST_DEBUG_OBJECT (pad, "setting PAD_MODE %d, unset flushing", new_mode);
 794       GST_PAD_UNSET_FLUSHING (pad);
 795       GST_PAD_MODE (pad) = new_mode;
 796       if (GST_PAD_IS_SINK (pad)) {
 797         GstPad *peer;
 798         /* make sure the peer src pad sends us all events */
 799         if ((peer = GST_PAD_PEER (pad))) {
 800           gst_object_ref (peer);
 801           GST_OBJECT_UNLOCK (pad);
 802
 803           GST_DEBUG_OBJECT (pad, "reschedule events on peer %s:%s",
 804               GST_DEBUG_PAD_NAME (peer));
 805
 806           GST_OBJECT_LOCK (peer);
 807           schedule_events (peer, NULL);
 808           GST_OBJECT_UNLOCK (peer);
 809
 810           gst_object_unref (peer);
 811         } else {
 812           GST_OBJECT_UNLOCK (pad);
 813         }
 814       } else {
 815         GST_OBJECT_UNLOCK (pad);
 816       }
 817       break;
 818   }
 819 }
 820
 821 static void
 822 post_activate (GstPad * pad, GstPadMode new_mode)
 823 {
 824   switch (new_mode) {
 825     case GST_PAD_MODE_NONE:
 826       /* ensures that streaming stops */
 827       GST_PAD_STREAM_LOCK (pad);
 828       GST_DEBUG_OBJECT (pad, "stopped streaming");
 829       GST_OBJECT_LOCK (pad);
 830       remove_events (pad);
 831       GST_OBJECT_UNLOCK (pad);
 832       GST_PAD_STREAM_UNLOCK (pad);
 833       break;
 834     case GST_PAD_MODE_PUSH:
 835     case GST_PAD_MODE_PULL:
 836       /* NOP */
 837       break;
 838   }
 839 }
 840
 841 /**
 842  * gst_pad_set_active:
 843  * @pad: the #GstPad to activate or deactivate.
 844  * @active: whether or not the pad should be active.
 845  *
 846  * Activates or deactivates the given pad.
 847  * Normally called from within core state change functions.
 848  *
 849  * If @active, makes sure the pad is active. If it is already active, either in
 850  * push or pull mode, just return. Otherwise dispatches to the pad's activate
 851  * function to perform the actual activation.
 852  *
 853  * If not @active, checks the pad's current mode and calls
 854  * gst_pad_activate_push() or gst_pad_activate_pull(), as appropriate, with a
 855  * FALSE argument.
 856  *
 857  * Returns: #TRUE if the operation was successful.
 858  *
 859  * MT safe.
 860  */
 861 gboolean
 862 gst_pad_set_active (GstPad * pad, gboolean active)
 863 {
 864   GstObject *parent;
 865   GstPadMode old;
 866   gboolean ret = FALSE;
 867
 868   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
 869
 870   GST_OBJECT_LOCK (pad);
 871   old = GST_PAD_MODE (pad);
 872   ACQUIRE_PARENT (pad, parent, no_parent);
 873   GST_OBJECT_UNLOCK (pad);
 874
 875   if (active) {
 876     if (old == GST_PAD_MODE_NONE) {
 877       GST_DEBUG_OBJECT (pad, "activating pad from none");
 878       ret = (GST_PAD_ACTIVATEFUNC (pad)) (pad, parent);
 879     } else {
 880       GST_DEBUG_OBJECT (pad, "pad was active in mode %d", old);
 881       ret = TRUE;
 882     }
 883   } else {
 884     if (old == GST_PAD_MODE_NONE) {
 885       GST_DEBUG_OBJECT (pad, "pad was inactive");
 886       ret = TRUE;
 887     } else {
 888       GST_DEBUG_OBJECT (pad, "deactivating pad from mode %d", old);
 889       ret = gst_pad_activate_mode (pad, old, FALSE);
 890     }
 891   }
 892
 893   RELEASE_PARENT (parent);
 894
 895   if (G_UNLIKELY (!ret))
 896     goto failed;
 897
 898   if (!active) {
 899     GST_OBJECT_LOCK (pad);
 900     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
 901     GST_OBJECT_UNLOCK (pad);
 902   }
 903   return ret;
 904
 905   /* ERRORS */
 906 no_parent:
 907   {
 908     GST_DEBUG_OBJECT (pad, "no parent");
 909     GST_OBJECT_UNLOCK (pad);
 910     return FALSE;
 911   }
 912 failed:
 913   {
 914     GST_OBJECT_LOCK (pad);
 915     if (!active) {
 916       g_critical ("Failed to deactivate pad %s:%s, very bad",
 917           GST_DEBUG_PAD_NAME (pad));
 918     } else {
 919       GST_WARNING_OBJECT (pad, "Failed to activate pad");
 920     }
 921     GST_OBJECT_UNLOCK (pad);
 922     return FALSE;
 923   }
 924 }
 925
 926 /**
 927  * gst_pad_activate_mode:
 928  * @pad: the #GstPad to activate or deactivate.
 929  * @mode: the requested activation mode
 930  * @active: whether or not the pad should be active.
 931  *
 932  * Activates or deactivates the given pad in @mode via dispatching to the
 933  * pad's activatemodefunc. For use from within pad activation functions only.
 934  *
 935  * If you don't know what this is, you probably don't want to call it.
 936  *
 937  * Returns: TRUE if the operation was successful.
 938  *
 939  * MT safe.
 940  */
 941 gboolean
 942 gst_pad_activate_mode (GstPad * pad, GstPadMode mode, gboolean active)
 943 {
 944   gboolean res = FALSE;
 945   GstObject *parent;
 946   GstPadMode old, new;
 947   GstPadDirection dir;
 948   GstPad *peer;
 949
 950   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
 951
 952   GST_OBJECT_LOCK (pad);
 953   old = GST_PAD_MODE (pad);
 954   dir = GST_PAD_DIRECTION (pad);
 955   ACQUIRE_PARENT (pad, parent, no_parent);
 956   GST_OBJECT_UNLOCK (pad);
 957
 958   new = active ? mode : GST_PAD_MODE_NONE;
 959
 960   if (old == new)
 961     goto was_ok;
 962
 963   if (active && old != mode) {
 964     /* pad was activate in the wrong direction, deactivate it
 965      * and reactivate it in the requested mode */
 966     GST_DEBUG_OBJECT (pad, "deactivating pad from mode %d", old);
 967     if (G_UNLIKELY (!gst_pad_activate_mode (pad, old, FALSE)))
 968       goto deactivate_failed;
 969   }
 970
 971   switch (mode) {
 972     case GST_PAD_MODE_PULL:
 973     {
 974       if (dir == GST_PAD_SINK) {
 975         if ((peer = gst_pad_get_peer (pad))) {
 976           GST_DEBUG_OBJECT (pad, "calling peer");
 977           if (G_UNLIKELY (!gst_pad_activate_mode (peer, mode, active)))
 978             goto peer_failed;
 979           gst_object_unref (peer);
 980         } else {
 981           /* there is no peer, this is only fatal when we activate. When we
 982            * deactivate, we must assume the application has unlinked the peer and
 983            * will deactivate it eventually. */
 984           if (active)
 985             goto not_linked;
 986           else
 987             GST_DEBUG_OBJECT (pad, "deactivating unlinked pad");
 988         }
 989       } else {
 990         if (G_UNLIKELY (GST_PAD_GETRANGEFUNC (pad) == NULL))
 991           goto failure;         /* Can't activate pull on a src without a
 992                                    getrange function */
 993       }
 994       break;
 995     }
 996     default:
 997       break;
 998   }
 999
1000   pre_activate (pad, new);
1001
1002   if (GST_PAD_ACTIVATEMODEFUNC (pad)) {
1003     if (G_UNLIKELY (!GST_PAD_ACTIVATEMODEFUNC (pad) (pad, parent, mode,
1004                 active)))
1005       goto failure;
1006   } else {
1007     /* can happen for sinks of passthrough elements */
1008   }
1009
1010   post_activate (pad, new);
1011
1012   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "%s in mode %d",
1013       active ? "activated" : "deactivated", mode);
1014
1015 exit_success:
1016   res = TRUE;
1017 exit:
1018   RELEASE_PARENT (parent);
1019
1020   return res;
1021
1022 no_parent:
1023   {
1024     GST_DEBUG_OBJECT (pad, "no parent");
1025     GST_OBJECT_UNLOCK (pad);
1026     return FALSE;
1027   }
1028 was_ok:
1029   {
1030     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "already %s in mode %d",
1031         active ? "activated" : "deactivated", mode);
1032     goto exit_success;
1033   }
1034 deactivate_failed:
1035   {
1036     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
1037         "failed to %s in switch to mode %d from mode %d",
1038         (active ? "activate" : "deactivate"), mode, old);
1039     goto exit;
1040   }
1041 peer_failed:
1042   {
1043     GST_OBJECT_LOCK (peer);
1044     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
1045         "activate_mode on peer (%s:%s) failed", GST_DEBUG_PAD_NAME (peer));
1046     GST_OBJECT_UNLOCK (peer);
1047     gst_object_unref (peer);
1048     goto exit;
1049   }
1050 not_linked:
1051   {
1052     GST_CAT_INFO_OBJECT (GST_CAT_PADS, pad, "can't activate unlinked sink "
1053         "pad in pull mode");
1054     goto exit;
1055   }
1056 failure:
1057   {
1058     GST_OBJECT_LOCK (pad);
1059     GST_CAT_INFO_OBJECT (GST_CAT_PADS, pad, "failed to %s in mode %d",
1060         active ? "activate" : "deactivate", mode);
1061     GST_PAD_SET_FLUSHING (pad);
1062     GST_PAD_MODE (pad) = old;
1063     GST_OBJECT_UNLOCK (pad);
1064     goto exit;
1065   }
1066 }
1067
1068 /**
1069  * gst_pad_is_active:
1070  * @pad: the #GstPad to query
1071  *
1072  * Query if a pad is active
1073  *
1074  * Returns: TRUE if the pad is active.
1075  *
1076  * MT safe.
1077  */
1078 gboolean
1079 gst_pad_is_active (GstPad * pad)
1080 {
1081   gboolean result = FALSE;
1082
1083   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1084
1085   GST_OBJECT_LOCK (pad);
1086   result = GST_PAD_IS_ACTIVE (pad);
1087   GST_OBJECT_UNLOCK (pad);
1088
1089   return result;
1090 }
1091
1092 /**
1093  * gst_pad_add_probe:
1094  * @pad: the #GstPad to add the probe to
1095  * @mask: the probe mask
1096  * @callback: #GstPadProbeCallback that will be called with notifications of
1097  *           the pad state
1098  * @user_data: (closure): user data passed to the callback
1099  * @destroy_data: #GDestroyNotify for user_data
1100  *
1101  * Be notified of different states of pads. The provided callback is called for
1102  * every state that matches @mask.
1103  *
1104  * Returns: an id or 0 on error. The id can be used to remove the probe with
1105  * gst_pad_remove_probe().
1106  *
1107  * MT safe.
1108  */
1109 gulong
1110 gst_pad_add_probe (GstPad * pad, GstPadProbeType mask,
1111     GstPadProbeCallback callback, gpointer user_data,
1112     GDestroyNotify destroy_data)
1113 {
1114   GHook *hook;
1115   gulong res;
1116
1117   g_return_val_if_fail (GST_IS_PAD (pad), 0);
1118   g_return_val_if_fail (mask != 0, 0);
1119
1120   GST_OBJECT_LOCK (pad);
1121
1122   /* make a new probe */
1123   hook = g_hook_alloc (&pad->probes);
1124
1125   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "adding probe for mask 0x%08x",
1126       mask);
1127
1128   /* when no contraints are given for the types, assume all types are
1129    * acceptable */
1130   if ((mask & GST_PAD_PROBE_TYPE_ALL_BOTH) == 0)
1131     mask |= GST_PAD_PROBE_TYPE_ALL_BOTH;
1132   if ((mask & GST_PAD_PROBE_TYPE_SCHEDULING) == 0)
1133     mask |= GST_PAD_PROBE_TYPE_SCHEDULING;
1134
1135   /* store our flags and other fields */
1136   hook->flags |= (mask << G_HOOK_FLAG_USER_SHIFT);
1137   hook->func = callback;
1138   hook->data = user_data;
1139   hook->destroy = destroy_data;
1140   PROBE_COOKIE (hook) = (pad->priv->probe_cookie - 1);
1141
1142   /* add the probe */
1143   g_hook_prepend (&pad->probes, hook);
1144   pad->num_probes++;
1145   /* incremenent cookie so that the new hook get's called */
1146   pad->priv->probe_list_cookie++;
1147
1148   /* get the id of the hook, we return this and it can be used to remove the
1149    * probe later */
1150   res = hook->hook_id;
1151
1152   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "got probe id %lu", res);
1153
1154   if (mask & GST_PAD_PROBE_TYPE_BLOCKING) {
1155     /* we have a block probe */
1156     pad->num_blocked++;
1157     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_BLOCKED);
1158     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "added blocking probe, "
1159         "now %d blocking probes", pad->num_blocked);
1160   }
1161
1162   /* call the callback if we need to be called for idle callbacks */
1163   if ((mask & GST_PAD_PROBE_TYPE_IDLE) && (callback != NULL)) {
1164     if (pad->priv->using > 0) {
1165       /* the pad is in use, we can't signal the idle callback yet. Since we set the
1166        * flag above, the last thread to leave the push will do the callback. New
1167        * threads going into the push will block. */
1168       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
1169           "pad is in use, delay idle callback");
1170       GST_OBJECT_UNLOCK (pad);
1171     } else {
1172       GstPadProbeInfo info = { GST_PAD_PROBE_TYPE_IDLE, res, };
1173
1174       /* the pad is idle now, we can signal the idle callback now */
1175       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
1176           "pad is idle, trigger idle callback");
1177       GST_OBJECT_UNLOCK (pad);
1178
1179       callback (pad, &info, user_data);
1180     }
1181   } else {
1182     GST_OBJECT_UNLOCK (pad);
1183   }
1184   return res;
1185 }
1186
1187 static void
1188 cleanup_hook (GstPad * pad, GHook * hook)
1189 {
1190   GstPadProbeType type;
1191
1192   type = (hook->flags) >> G_HOOK_FLAG_USER_SHIFT;
1193
1194   if (type & GST_PAD_PROBE_TYPE_BLOCKING) {
1195     /* unblock when we remove the last blocking probe */
1196     pad->num_blocked--;
1197     GST_DEBUG_OBJECT (pad, "remove blocking probe, now %d left",
1198         pad->num_blocked);
1199     if (pad->num_blocked == 0) {
1200       GST_DEBUG_OBJECT (pad, "last blocking probe removed, unblocking");
1201       GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_BLOCKED);
1202       GST_PAD_BLOCK_BROADCAST (pad);
1203     }
1204   }
1205   g_hook_destroy_link (&pad->probes, hook);
1206   pad->num_probes--;
1207 }
1208
1209 /**
1210  * gst_pad_remove_probe:
1211  * @pad: the #GstPad with the probe
1212  * @id: the probe id to remove
1213  *
1214  * Remove the probe with @id from @pad.
1215  *
1216  * MT safe.
1217  */
1218 void
1219 gst_pad_remove_probe (GstPad * pad, gulong id)
1220 {
1221   GHook *hook;
1222
1223   g_return_if_fail (GST_IS_PAD (pad));
1224
1225   GST_OBJECT_LOCK (pad);
1226
1227   hook = g_hook_get (&pad->probes, id);
1228   if (hook == NULL)
1229     goto not_found;
1230
1231   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "removing hook %ld",
1232       hook->hook_id);
1233   cleanup_hook (pad, hook);
1234   GST_OBJECT_UNLOCK (pad);
1235
1236   return;
1237
1238 not_found:
1239   {
1240     GST_OBJECT_UNLOCK (pad);
1241     g_warning ("%s: pad `%p' has no probe with id `%lu'", G_STRLOC, pad, id);
1242     return;
1243   }
1244 }
1245
1246 /**
1247  * gst_pad_is_blocked:
1248  * @pad: the #GstPad to query
1249  *
1250  * Checks if the pad is blocked or not. This function returns the
1251  * last requested state of the pad. It is not certain that the pad
1252  * is actually blocking at this point (see gst_pad_is_blocking()).
1253  *
1254  * Returns: TRUE if the pad is blocked.
1255  *
1256  * MT safe.
1257  */
1258 gboolean
1259 gst_pad_is_blocked (GstPad * pad)
1260 {
1261   gboolean result = FALSE;
1262
1263   g_return_val_if_fail (GST_IS_PAD (pad), result);
1264
1265   GST_OBJECT_LOCK (pad);
1266   result = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_BLOCKED);
1267   GST_OBJECT_UNLOCK (pad);
1268
1269   return result;
1270 }
1271
1272 /**
1273  * gst_pad_is_blocking:
1274  * @pad: the #GstPad to query
1275  *
1276  * Checks if the pad is blocking or not. This is a guaranteed state
1277  * of whether the pad is actually blocking on a #GstBuffer or a #GstEvent.
1278  *
1279  * Returns: TRUE if the pad is blocking.
1280  *
1281  * MT safe.
1282  *
1283  * Since: 0.10.11
1284  */
1285 gboolean
1286 gst_pad_is_blocking (GstPad * pad)
1287 {
1288   gboolean result = FALSE;
1289
1290   g_return_val_if_fail (GST_IS_PAD (pad), result);
1291
1292   GST_OBJECT_LOCK (pad);
1293   /* the blocking flag is only valid if the pad is not flushing */
1294   result = GST_PAD_IS_BLOCKING (pad) && !GST_PAD_IS_FLUSHING (pad);
1295   GST_OBJECT_UNLOCK (pad);
1296
1297   return result;
1298 }
1299
1300 /**
1301  * gst_pad_check_reconfigure:
1302  * @pad: the #GstPad to check
1303  *
1304  * Check and clear the #GST_PAD_FLAG_NEED_RECONFIGURE flag on @pad and return %TRUE
1305  * if the flag was set.
1306  *
1307  * Returns: %TRUE is the GST_PAD_FLAG_NEED_RECONFIGURE flag was set on @pad.
1308  */
1309 gboolean
1310 gst_pad_check_reconfigure (GstPad * pad)
1311 {
1312   gboolean reconfigure;
1313
1314   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1315
1316   GST_OBJECT_LOCK (pad);
1317   reconfigure = GST_PAD_NEEDS_RECONFIGURE (pad);
1318   GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
1319   GST_OBJECT_UNLOCK (pad);
1320
1321   return reconfigure;
1322 }
1323
1324 /**
1325  * gst_pad_mark_reconfigure:
1326  * @pad: the #GstPad to mark
1327  *
1328  * Mark a pad for needing reconfiguration. The next call to
1329  * gst_pad_check_reconfigure() will return %TRUE after this call.
1330  */
1331 void
1332 gst_pad_mark_reconfigure (GstPad * pad)
1333 {
1334   g_return_if_fail (GST_IS_PAD (pad));
1335
1336   GST_OBJECT_LOCK (pad);
1337   GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
1338   GST_OBJECT_UNLOCK (pad);
1339 }
1340
1341 /**
1342  * gst_pad_set_activate_function_full:
1343  * @pad: a #GstPad.
1344  * @activate: the #GstPadActivateFunction to set.
1345  * @user_data: user_data passed to @notify
1346  * @notify: notify called when @activate will not be used anymore.
1347  *
1348  * Sets the given activate function for @pad. The activate function will
1349  * dispatch to gst_pad_activate_push() or gst_pad_activate_pull() to perform
1350  * the actual activation. Only makes sense to set on sink pads.
1351  *
1352  * Call this function if your sink pad can start a pull-based task.
1353  */
1354 void
1355 gst_pad_set_activate_function_full (GstPad * pad,
1356     GstPadActivateFunction activate, gpointer user_data, GDestroyNotify notify)
1357 {
1358   g_return_if_fail (GST_IS_PAD (pad));
1359
1360   if (pad->activatenotify)
1361     pad->activatenotify (pad->activatedata);
1362   GST_PAD_ACTIVATEFUNC (pad) = activate;
1363   pad->activatedata = user_data;
1364   pad->activatenotify = notify;
1365
1366   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "activatefunc set to %s",
1367       GST_DEBUG_FUNCPTR_NAME (activate));
1368 }
1369
1370 /**
1371  * gst_pad_set_activatemode_function_full:
1372  * @pad: a #GstPad.
1373  * @activatemode: the #GstPadActivateModeFunction to set.
1374  * @user_data: user_data passed to @notify
1375  * @notify: notify called when @activatemode will not be used anymore.
1376  *
1377  * Sets the given activate_mode function for the pad. An activate_mode function
1378  * prepares the element for data passing.
1379  */
1380 void
1381 gst_pad_set_activatemode_function_full (GstPad * pad,
1382     GstPadActivateModeFunction activatemode, gpointer user_data,
1383     GDestroyNotify notify)
1384 {
1385   g_return_if_fail (GST_IS_PAD (pad));
1386
1387   if (pad->activatemodenotify)
1388     pad->activatemodenotify (pad->activatemodedata);
1389   GST_PAD_ACTIVATEMODEFUNC (pad) = activatemode;
1390   pad->activatemodedata = user_data;
1391   pad->activatemodenotify = notify;
1392
1393   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "activatemodefunc set to %s",
1394       GST_DEBUG_FUNCPTR_NAME (activatemode));
1395 }
1396
1397 /**
1398  * gst_pad_set_chain_function_full:
1399  * @pad: a sink #GstPad.
1400  * @chain: the #GstPadChainFunction to set.
1401  * @user_data: user_data passed to @notify
1402  * @notify: notify called when @chain will not be used anymore.
1403  *
1404  * Sets the given chain function for the pad. The chain function is called to
1405  * process a #GstBuffer input buffer. see #GstPadChainFunction for more details.
1406  */
1407 void
1408 gst_pad_set_chain_function_full (GstPad * pad, GstPadChainFunction chain,
1409     gpointer user_data, GDestroyNotify notify)
1410 {
1411   g_return_if_fail (GST_IS_PAD (pad));
1412   g_return_if_fail (GST_PAD_IS_SINK (pad));
1413
1414   if (pad->chainnotify)
1415     pad->chainnotify (pad->chaindata);
1416   GST_PAD_CHAINFUNC (pad) = chain;
1417   pad->chaindata = user_data;
1418   pad->chainnotify = notify;
1419
1420   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "chainfunc set to %s",
1421       GST_DEBUG_FUNCPTR_NAME (chain));
1422 }
1423
1424 /**
1425  * gst_pad_set_chain_list_function_full:
1426  * @pad: a sink #GstPad.
1427  * @chainlist: the #GstPadChainListFunction to set.
1428  * @user_data: user_data passed to @notify
1429  * @notify: notify called when @chainlist will not be used anymore.
1430  *
1431  * Sets the given chain list function for the pad. The chainlist function is
1432  * called to process a #GstBufferList input buffer list. See
1433  * #GstPadChainListFunction for more details.
1434  *
1435  * Since: 0.10.24
1436  */
1437 void
1438 gst_pad_set_chain_list_function_full (GstPad * pad,
1439     GstPadChainListFunction chainlist, gpointer user_data,
1440     GDestroyNotify notify)
1441 {
1442   g_return_if_fail (GST_IS_PAD (pad));
1443   g_return_if_fail (GST_PAD_IS_SINK (pad));
1444
1445   if (pad->chainlistnotify)
1446     pad->chainlistnotify (pad->chainlistdata);
1447   GST_PAD_CHAINLISTFUNC (pad) = chainlist;
1448   pad->chainlistdata = user_data;
1449   pad->chainlistnotify = notify;
1450
1451   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "chainlistfunc set to %s",
1452       GST_DEBUG_FUNCPTR_NAME (chainlist));
1453 }
1454
1455 /**
1456  * gst_pad_set_getrange_function_full:
1457  * @pad: a source #GstPad.
1458  * @get: the #GstPadGetRangeFunction to set.
1459  * @user_data: user_data passed to @notify
1460  * @notify: notify called when @get will not be used anymore.
1461  *
1462  * Sets the given getrange function for the pad. The getrange function is
1463  * called to produce a new #GstBuffer to start the processing pipeline. see
1464  * #GstPadGetRangeFunction for a description of the getrange function.
1465  */
1466 void
1467 gst_pad_set_getrange_function_full (GstPad * pad, GstPadGetRangeFunction get,
1468     gpointer user_data, GDestroyNotify notify)
1469 {
1470   g_return_if_fail (GST_IS_PAD (pad));
1471   g_return_if_fail (GST_PAD_IS_SRC (pad));
1472
1473   if (pad->getrangenotify)
1474     pad->getrangenotify (pad->getrangedata);
1475   GST_PAD_GETRANGEFUNC (pad) = get;
1476   pad->getrangedata = user_data;
1477   pad->getrangenotify = notify;
1478
1479   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "getrangefunc set to %s",
1480       GST_DEBUG_FUNCPTR_NAME (get));
1481 }
1482
1483 /**
1484  * gst_pad_set_event_function_full:
1485  * @pad: a #GstPad of either direction.
1486  * @event: the #GstPadEventFunction to set.
1487  * @user_data: user_data passed to @notify
1488  * @notify: notify called when @event will not be used anymore.
1489  *
1490  * Sets the given event handler for the pad.
1491  */
1492 void
1493 gst_pad_set_event_function_full (GstPad * pad, GstPadEventFunction event,
1494     gpointer user_data, GDestroyNotify notify)
1495 {
1496   g_return_if_fail (GST_IS_PAD (pad));
1497
1498   if (pad->eventnotify)
1499     pad->eventnotify (pad->eventdata);
1500   GST_PAD_EVENTFUNC (pad) = event;
1501   pad->eventdata = user_data;
1502   pad->eventnotify = notify;
1503
1504   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "eventfunc for set to %s",
1505       GST_DEBUG_FUNCPTR_NAME (event));
1506 }
1507
1508 /**
1509  * gst_pad_set_query_function_full:
1510  * @pad: a #GstPad of either direction.
1511  * @query: the #GstPadQueryFunction to set.
1512  * @user_data: user_data passed to @notify
1513  * @notify: notify called when @query will not be used anymore.
1514  *
1515  * Set the given query function for the pad.
1516  */
1517 void
1518 gst_pad_set_query_function_full (GstPad * pad, GstPadQueryFunction query,
1519     gpointer user_data, GDestroyNotify notify)
1520 {
1521   g_return_if_fail (GST_IS_PAD (pad));
1522
1523   if (pad->querynotify)
1524     pad->querynotify (pad->querydata);
1525   GST_PAD_QUERYFUNC (pad) = query;
1526   pad->querydata = user_data;
1527   pad->querynotify = notify;
1528
1529   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "queryfunc set to %s",
1530       GST_DEBUG_FUNCPTR_NAME (query));
1531 }
1532
1533 /**
1534  * gst_pad_set_iterate_internal_links_function_full:
1535  * @pad: a #GstPad of either direction.
1536  * @iterintlink: the #GstPadIterIntLinkFunction to set.
1537  * @user_data: user_data passed to @notify
1538  * @notify: notify called when @iterintlink will not be used anymore.
1539  *
1540  * Sets the given internal link iterator function for the pad.
1541  *
1542  * Since: 0.10.21
1543  */
1544 void
1545 gst_pad_set_iterate_internal_links_function_full (GstPad * pad,
1546     GstPadIterIntLinkFunction iterintlink, gpointer user_data,
1547     GDestroyNotify notify)
1548 {
1549   g_return_if_fail (GST_IS_PAD (pad));
1550
1551   if (pad->iterintlinknotify)
1552     pad->iterintlinknotify (pad->iterintlinkdata);
1553   GST_PAD_ITERINTLINKFUNC (pad) = iterintlink;
1554   pad->iterintlinkdata = user_data;
1555   pad->iterintlinknotify = notify;
1556
1557   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "internal link iterator set to %s",
1558       GST_DEBUG_FUNCPTR_NAME (iterintlink));
1559 }
1560
1561 /**
1562  * gst_pad_set_link_function_full:
1563  * @pad: a #GstPad.
1564  * @link: the #GstPadLinkFunction to set.
1565  * @user_data: user_data passed to @notify
1566  * @notify: notify called when @link will not be used anymore.
1567  *
1568  * Sets the given link function for the pad. It will be called when
1569  * the pad is linked with another pad.
1570  *
1571  * The return value #GST_PAD_LINK_OK should be used when the connection can be
1572  * made.
1573  *
1574  * The return value #GST_PAD_LINK_REFUSED should be used when the connection
1575  * cannot be made for some reason.
1576  *
1577  * If @link is installed on a source pad, it should call the #GstPadLinkFunction
1578  * of the peer sink pad, if present.
1579  */
1580 void
1581 gst_pad_set_link_function_full (GstPad * pad, GstPadLinkFunction link,
1582     gpointer user_data, GDestroyNotify notify)
1583 {
1584   g_return_if_fail (GST_IS_PAD (pad));
1585
1586   if (pad->linknotify)
1587     pad->linknotify (pad->linkdata);
1588   GST_PAD_LINKFUNC (pad) = link;
1589   pad->linkdata = user_data;
1590   pad->linknotify = notify;
1591
1592   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "linkfunc set to %s",
1593       GST_DEBUG_FUNCPTR_NAME (link));
1594 }
1595
1596 /**
1597  * gst_pad_set_unlink_function_full:
1598  * @pad: a #GstPad.
1599  * @unlink: the #GstPadUnlinkFunction to set.
1600  * @user_data: user_data passed to @notify
1601  * @notify: notify called when @unlink will not be used anymore.
1602  *
1603  * Sets the given unlink function for the pad. It will be called
1604  * when the pad is unlinked.
1605  */
1606 void
1607 gst_pad_set_unlink_function_full (GstPad * pad, GstPadUnlinkFunction unlink,
1608     gpointer user_data, GDestroyNotify notify)
1609 {
1610   g_return_if_fail (GST_IS_PAD (pad));
1611
1612   if (pad->unlinknotify)
1613     pad->unlinknotify (pad->unlinkdata);
1614   GST_PAD_UNLINKFUNC (pad) = unlink;
1615   pad->unlinkdata = user_data;
1616   pad->unlinknotify = notify;
1617
1618   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "unlinkfunc set to %s",
1619       GST_DEBUG_FUNCPTR_NAME (unlink));
1620 }
1621
1622 /**
1623  * gst_pad_unlink:
1624  * @srcpad: the source #GstPad to unlink.
1625  * @sinkpad: the sink #GstPad to unlink.
1626  *
1627  * Unlinks the source pad from the sink pad. Will emit the #GstPad::unlinked
1628  * signal on both pads.
1629  *
1630  * Returns: TRUE if the pads were unlinked. This function returns FALSE if
1631  * the pads were not linked together.
1632  *
1633  * MT safe.
1634  */
1635 gboolean
1636 gst_pad_unlink (GstPad * srcpad, GstPad * sinkpad)
1637 {
1638   gboolean result = FALSE;
1639   GstElement *parent = NULL;
1640
1641   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
1642   g_return_val_if_fail (GST_PAD_IS_SRC (srcpad), FALSE);
1643   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
1644   g_return_val_if_fail (GST_PAD_IS_SINK (sinkpad), FALSE);
1645
1646   GST_CAT_INFO (GST_CAT_ELEMENT_PADS, "unlinking %s:%s(%p) and %s:%s(%p)",
1647       GST_DEBUG_PAD_NAME (srcpad), srcpad,
1648       GST_DEBUG_PAD_NAME (sinkpad), sinkpad);
1649
1650   /* We need to notify the parent before taking any pad locks as the bin in
1651    * question might be waiting for a lock on the pad while holding its lock
1652    * that our message will try to take. */
1653   if ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (srcpad)))) {
1654     if (GST_IS_ELEMENT (parent)) {
1655       gst_element_post_message (parent,
1656           gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
1657               GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK, parent, TRUE));
1658     } else {
1659       gst_object_unref (parent);
1660       parent = NULL;
1661     }
1662   }
1663
1664   GST_OBJECT_LOCK (srcpad);
1665   GST_OBJECT_LOCK (sinkpad);
1666
1667   if (G_UNLIKELY (GST_PAD_PEER (srcpad) != sinkpad))
1668     goto not_linked_together;
1669
1670   if (GST_PAD_UNLINKFUNC (srcpad)) {
1671     GST_PAD_UNLINKFUNC (srcpad) (srcpad);
1672   }
1673   if (GST_PAD_UNLINKFUNC (sinkpad)) {
1674     GST_PAD_UNLINKFUNC (sinkpad) (sinkpad);
1675   }
1676
1677   /* first clear peers */
1678   GST_PAD_PEER (srcpad) = NULL;
1679   GST_PAD_PEER (sinkpad) = NULL;
1680
1681   GST_OBJECT_UNLOCK (sinkpad);
1682   GST_OBJECT_UNLOCK (srcpad);
1683
1684   /* fire off a signal to each of the pads telling them
1685    * that they've been unlinked */
1686   g_signal_emit (srcpad, gst_pad_signals[PAD_UNLINKED], 0, sinkpad);
1687   g_signal_emit (sinkpad, gst_pad_signals[PAD_UNLINKED], 0, srcpad);
1688
1689   GST_CAT_INFO (GST_CAT_ELEMENT_PADS, "unlinked %s:%s and %s:%s",
1690       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
1691
1692   result = TRUE;
1693
1694 done:
1695   if (parent != NULL) {
1696     gst_element_post_message (parent,
1697         gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
1698             GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK, parent, FALSE));
1699     gst_object_unref (parent);
1700   }
1701   return result;
1702
1703   /* ERRORS */
1704 not_linked_together:
1705   {
1706     /* we do not emit a warning in this case because unlinking cannot
1707      * be made MT safe.*/
1708     GST_OBJECT_UNLOCK (sinkpad);
1709     GST_OBJECT_UNLOCK (srcpad);
1710     goto done;
1711   }
1712 }
1713
1714 /**
1715  * gst_pad_is_linked:
1716  * @pad: pad to check
1717  *
1718  * Checks if a @pad is linked to another pad or not.
1719  *
1720  * Returns: TRUE if the pad is linked, FALSE otherwise.
1721  *
1722  * MT safe.
1723  */
1724 gboolean
1725 gst_pad_is_linked (GstPad * pad)
1726 {
1727   gboolean result;
1728
1729   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1730
1731   GST_OBJECT_LOCK (pad);
1732   result = (GST_PAD_PEER (pad) != NULL);
1733   GST_OBJECT_UNLOCK (pad);
1734
1735   return result;
1736 }
1737
1738 /* get the caps from both pads and see if the intersection
1739  * is not empty.
1740  *
1741  * This function should be called with the pad LOCK on both
1742  * pads
1743  */
1744 static gboolean
1745 gst_pad_link_check_compatible_unlocked (GstPad * src, GstPad * sink,
1746     GstPadLinkCheck flags)
1747 {
1748   GstCaps *srccaps = NULL;
1749   GstCaps *sinkcaps = NULL;
1750   gboolean compatible = FALSE;
1751
1752   if (!(flags & (GST_PAD_LINK_CHECK_CAPS | GST_PAD_LINK_CHECK_TEMPLATE_CAPS)))
1753     return TRUE;
1754
1755   /* Doing the expensive caps checking takes priority over only checking the template caps */
1756   if (flags & GST_PAD_LINK_CHECK_CAPS) {
1757     GST_OBJECT_UNLOCK (sink);
1758     GST_OBJECT_UNLOCK (src);
1759
1760     srccaps = gst_pad_query_caps (src, NULL);
1761     sinkcaps = gst_pad_query_caps (sink, NULL);
1762
1763     GST_OBJECT_LOCK (src);
1764     GST_OBJECT_LOCK (sink);
1765   } else {
1766     /* If one of the two pads doesn't have a template, consider the intersection
1767      * as valid.*/
1768     if (G_UNLIKELY ((GST_PAD_PAD_TEMPLATE (src) == NULL)
1769             || (GST_PAD_PAD_TEMPLATE (sink) == NULL))) {
1770       compatible = TRUE;
1771       goto done;
1772     }
1773     srccaps = gst_caps_ref (GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (src)));
1774     sinkcaps =
1775         gst_caps_ref (GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (sink)));
1776   }
1777
1778   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, src, "src caps %" GST_PTR_FORMAT,
1779       srccaps);
1780   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, sink, "sink caps %" GST_PTR_FORMAT,
1781       sinkcaps);
1782
1783   /* if we have caps on both pads we can check the intersection. If one
1784    * of the caps is NULL, we return TRUE. */
1785   if (G_UNLIKELY (srccaps == NULL || sinkcaps == NULL)) {
1786     if (srccaps)
1787       gst_caps_unref (srccaps);
1788     if (sinkcaps)
1789       gst_caps_unref (sinkcaps);
1790     goto done;
1791   }
1792
1793   compatible = gst_caps_can_intersect (srccaps, sinkcaps);
1794   gst_caps_unref (srccaps);
1795   gst_caps_unref (sinkcaps);
1796
1797 done:
1798   GST_CAT_DEBUG (GST_CAT_CAPS, "caps are %scompatible",
1799       (compatible ? "" : "not"));
1800
1801   return compatible;
1802 }
1803
1804 /* check if the grandparents of both pads are the same.
1805  * This check is required so that we don't try to link
1806  * pads from elements in different bins without ghostpads.
1807  *
1808  * The LOCK should be held on both pads
1809  */
1810 static gboolean
1811 gst_pad_link_check_hierarchy (GstPad * src, GstPad * sink)
1812 {
1813   GstObject *psrc, *psink;
1814
1815   psrc = GST_OBJECT_PARENT (src);
1816   psink = GST_OBJECT_PARENT (sink);
1817
1818   /* if one of the pads has no parent, we allow the link */
1819   if (G_UNLIKELY (psrc == NULL || psink == NULL))
1820     goto no_parent;
1821
1822   /* only care about parents that are elements */
1823   if (G_UNLIKELY (!GST_IS_ELEMENT (psrc) || !GST_IS_ELEMENT (psink)))
1824     goto no_element_parent;
1825
1826   /* if the parents are the same, we have a loop */
1827   if (G_UNLIKELY (psrc == psink))
1828     goto same_parents;
1829
1830   /* if they both have a parent, we check the grandparents. We can not lock
1831    * the parent because we hold on the child (pad) and the locking order is
1832    * parent >> child. */
1833   psrc = GST_OBJECT_PARENT (psrc);
1834   psink = GST_OBJECT_PARENT (psink);
1835
1836   /* if they have grandparents but they are not the same */
1837   if (G_UNLIKELY (psrc != psink))
1838     goto wrong_grandparents;
1839
1840   return TRUE;
1841
1842   /* ERRORS */
1843 no_parent:
1844   {
1845     GST_CAT_DEBUG (GST_CAT_CAPS,
1846         "one of the pads has no parent %" GST_PTR_FORMAT " and %"
1847         GST_PTR_FORMAT, psrc, psink);
1848     return TRUE;
1849   }
1850 no_element_parent:
1851   {
1852     GST_CAT_DEBUG (GST_CAT_CAPS,
1853         "one of the pads has no element parent %" GST_PTR_FORMAT " and %"
1854         GST_PTR_FORMAT, psrc, psink);
1855     return TRUE;
1856   }
1857 same_parents:
1858   {
1859     GST_CAT_DEBUG (GST_CAT_CAPS, "pads have same parent %" GST_PTR_FORMAT,
1860         psrc);
1861     return FALSE;
1862   }
1863 wrong_grandparents:
1864   {
1865     GST_CAT_DEBUG (GST_CAT_CAPS,
1866         "pads have different grandparents %" GST_PTR_FORMAT " and %"
1867         GST_PTR_FORMAT, psrc, psink);
1868     return FALSE;
1869   }
1870 }
1871
1872 /* FIXME leftover from an attempt at refactoring... */
1873 /* call with the two pads unlocked, when this function returns GST_PAD_LINK_OK,
1874  * the two pads will be locked in the srcpad, sinkpad order. */
1875 static GstPadLinkReturn
1876 gst_pad_link_prepare (GstPad * srcpad, GstPad * sinkpad, GstPadLinkCheck flags)
1877 {
1878   GST_CAT_INFO (GST_CAT_PADS, "trying to link %s:%s and %s:%s",
1879       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
1880
1881   GST_OBJECT_LOCK (srcpad);
1882
1883   if (G_UNLIKELY (GST_PAD_PEER (srcpad) != NULL))
1884     goto src_was_linked;
1885
1886   GST_OBJECT_LOCK (sinkpad);
1887
1888   if (G_UNLIKELY (GST_PAD_PEER (sinkpad) != NULL))
1889     goto sink_was_linked;
1890
1891   /* check hierarchy, pads can only be linked if the grandparents
1892    * are the same. */
1893   if ((flags & GST_PAD_LINK_CHECK_HIERARCHY)
1894       && !gst_pad_link_check_hierarchy (srcpad, sinkpad))
1895     goto wrong_hierarchy;
1896
1897   /* check pad caps for non-empty intersection */
1898   if (!gst_pad_link_check_compatible_unlocked (srcpad, sinkpad, flags))
1899     goto no_format;
1900
1901   /* FIXME check pad scheduling for non-empty intersection */
1902
1903   return GST_PAD_LINK_OK;
1904
1905 src_was_linked:
1906   {
1907     GST_CAT_INFO (GST_CAT_PADS, "src %s:%s was already linked to %s:%s",
1908         GST_DEBUG_PAD_NAME (srcpad),
1909         GST_DEBUG_PAD_NAME (GST_PAD_PEER (srcpad)));
1910     /* we do not emit a warning in this case because unlinking cannot
1911      * be made MT safe.*/
1912     GST_OBJECT_UNLOCK (srcpad);
1913     return GST_PAD_LINK_WAS_LINKED;
1914   }
1915 sink_was_linked:
1916   {
1917     GST_CAT_INFO (GST_CAT_PADS, "sink %s:%s was already linked to %s:%s",
1918         GST_DEBUG_PAD_NAME (sinkpad),
1919         GST_DEBUG_PAD_NAME (GST_PAD_PEER (sinkpad)));
1920     /* we do not emit a warning in this case because unlinking cannot
1921      * be made MT safe.*/
1922     GST_OBJECT_UNLOCK (sinkpad);
1923     GST_OBJECT_UNLOCK (srcpad);
1924     return GST_PAD_LINK_WAS_LINKED;
1925   }
1926 wrong_hierarchy:
1927   {
1928     GST_CAT_INFO (GST_CAT_PADS, "pads have wrong hierarchy");
1929     GST_OBJECT_UNLOCK (sinkpad);
1930     GST_OBJECT_UNLOCK (srcpad);
1931     return GST_PAD_LINK_WRONG_HIERARCHY;
1932   }
1933 no_format:
1934   {
1935     GST_CAT_INFO (GST_CAT_PADS, "caps are incompatible");
1936     GST_OBJECT_UNLOCK (sinkpad);
1937     GST_OBJECT_UNLOCK (srcpad);
1938     return GST_PAD_LINK_NOFORMAT;
1939   }
1940 }
1941
1942 /**
1943  * gst_pad_can_link:
1944  * @srcpad: the source #GstPad.
1945  * @sinkpad: the sink #GstPad.
1946  *
1947  * Checks if the source pad and the sink pad are compatible so they can be
1948  * linked.
1949  *
1950  * Returns: TRUE if the pads can be linked.
1951  */
1952 gboolean
1953 gst_pad_can_link (GstPad * srcpad, GstPad * sinkpad)
1954 {
1955   GstPadLinkReturn result;
1956
1957   /* generic checks */
1958   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
1959   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
1960
1961   GST_CAT_INFO (GST_CAT_PADS, "check if %s:%s can link with %s:%s",
1962       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
1963
1964   /* gst_pad_link_prepare does everything for us, we only release the locks
1965    * on the pads that it gets us. If this function returns !OK the locks are not
1966    * taken anymore. */
1967   result = gst_pad_link_prepare (srcpad, sinkpad, GST_PAD_LINK_CHECK_DEFAULT);
1968   if (result != GST_PAD_LINK_OK)
1969     goto done;
1970
1971   GST_OBJECT_UNLOCK (srcpad);
1972   GST_OBJECT_UNLOCK (sinkpad);
1973
1974 done:
1975   return result == GST_PAD_LINK_OK;
1976 }
1977
1978 /**
1979  * gst_pad_link_full:
1980  * @srcpad: the source #GstPad to link.
1981  * @sinkpad: the sink #GstPad to link.
1982  * @flags: the checks to validate when linking
1983  *
1984  * Links the source pad and the sink pad.
1985  *
1986  * This variant of #gst_pad_link provides a more granular control on the
1987  * checks being done when linking. While providing some considerable speedups
1988  * the caller of this method must be aware that wrong usage of those flags
1989  * can cause severe issues. Refer to the documentation of #GstPadLinkCheck
1990  * for more information.
1991  *
1992  * MT Safe.
1993  *
1994  * Returns: A result code indicating if the connection worked or
1995  *          what went wrong.
1996  *
1997  * Since: 0.10.30
1998  */
1999 GstPadLinkReturn
2000 gst_pad_link_full (GstPad * srcpad, GstPad * sinkpad, GstPadLinkCheck flags)
2001 {
2002   GstPadLinkReturn result;
2003   GstElement *parent;
2004   GstPadLinkFunction srcfunc, sinkfunc;
2005
2006   g_return_val_if_fail (GST_IS_PAD (srcpad), GST_PAD_LINK_REFUSED);
2007   g_return_val_if_fail (GST_PAD_IS_SRC (srcpad), GST_PAD_LINK_WRONG_DIRECTION);
2008   g_return_val_if_fail (GST_IS_PAD (sinkpad), GST_PAD_LINK_REFUSED);
2009   g_return_val_if_fail (GST_PAD_IS_SINK (sinkpad),
2010       GST_PAD_LINK_WRONG_DIRECTION);
2011
2012   /* Notify the parent early. See gst_pad_unlink for details. */
2013   if (G_LIKELY ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (srcpad))))) {
2014     if (G_LIKELY (GST_IS_ELEMENT (parent))) {
2015       gst_element_post_message (parent,
2016           gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2017               GST_STRUCTURE_CHANGE_TYPE_PAD_LINK, parent, TRUE));
2018     } else {
2019       gst_object_unref (parent);
2020       parent = NULL;
2021     }
2022   }
2023
2024   /* prepare will also lock the two pads */
2025   result = gst_pad_link_prepare (srcpad, sinkpad, flags);
2026
2027   if (G_UNLIKELY (result != GST_PAD_LINK_OK))
2028     goto done;
2029
2030   /* must set peers before calling the link function */
2031   GST_PAD_PEER (srcpad) = sinkpad;
2032   GST_PAD_PEER (sinkpad) = srcpad;
2033
2034   /* check events, when something is different, mark pending */
2035   schedule_events (srcpad, sinkpad);
2036
2037   /* get the link functions */
2038   srcfunc = GST_PAD_LINKFUNC (srcpad);
2039   sinkfunc = GST_PAD_LINKFUNC (sinkpad);
2040
2041   if (G_UNLIKELY (srcfunc || sinkfunc)) {
2042     /* custom link functions, execute them */
2043     GST_OBJECT_UNLOCK (sinkpad);
2044     GST_OBJECT_UNLOCK (srcpad);
2045
2046     if (srcfunc) {
2047       /* this one will call the peer link function */
2048       result = srcfunc (srcpad, sinkpad);
2049     } else if (sinkfunc) {
2050       /* if no source link function, we need to call the sink link
2051        * function ourselves. */
2052       result = sinkfunc (sinkpad, srcpad);
2053     }
2054
2055     GST_OBJECT_LOCK (srcpad);
2056     GST_OBJECT_LOCK (sinkpad);
2057
2058     /* we released the lock, check if the same pads are linked still */
2059     if (GST_PAD_PEER (srcpad) != sinkpad || GST_PAD_PEER (sinkpad) != srcpad)
2060       goto concurrent_link;
2061
2062     if (G_UNLIKELY (result != GST_PAD_LINK_OK))
2063       goto link_failed;
2064   }
2065   GST_OBJECT_UNLOCK (sinkpad);
2066   GST_OBJECT_UNLOCK (srcpad);
2067
2068   /* fire off a signal to each of the pads telling them
2069    * that they've been linked */
2070   g_signal_emit (srcpad, gst_pad_signals[PAD_LINKED], 0, sinkpad);
2071   g_signal_emit (sinkpad, gst_pad_signals[PAD_LINKED], 0, srcpad);
2072
2073   GST_CAT_INFO (GST_CAT_PADS, "linked %s:%s and %s:%s, successful",
2074       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2075
2076   gst_pad_send_event (srcpad, gst_event_new_reconfigure ());
2077
2078 done:
2079   if (G_LIKELY (parent)) {
2080     gst_element_post_message (parent,
2081         gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2082             GST_STRUCTURE_CHANGE_TYPE_PAD_LINK, parent, FALSE));
2083     gst_object_unref (parent);
2084   }
2085
2086   return result;
2087
2088   /* ERRORS */
2089 concurrent_link:
2090   {
2091     GST_CAT_INFO (GST_CAT_PADS, "concurrent link between %s:%s and %s:%s",
2092         GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2093     GST_OBJECT_UNLOCK (sinkpad);
2094     GST_OBJECT_UNLOCK (srcpad);
2095
2096     /* The other link operation succeeded first */
2097     result = GST_PAD_LINK_WAS_LINKED;
2098     goto done;
2099   }
2100 link_failed:
2101   {
2102     GST_CAT_INFO (GST_CAT_PADS, "link between %s:%s and %s:%s failed",
2103         GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2104
2105     GST_PAD_PEER (srcpad) = NULL;
2106     GST_PAD_PEER (sinkpad) = NULL;
2107
2108     GST_OBJECT_UNLOCK (sinkpad);
2109     GST_OBJECT_UNLOCK (srcpad);
2110
2111     goto done;
2112   }
2113 }
2114
2115 /**
2116  * gst_pad_link:
2117  * @srcpad: the source #GstPad to link.
2118  * @sinkpad: the sink #GstPad to link.
2119  *
2120  * Links the source pad and the sink pad.
2121  *
2122  * Returns: A result code indicating if the connection worked or
2123  *          what went wrong.
2124  *
2125  * MT Safe.
2126  */
2127 GstPadLinkReturn
2128 gst_pad_link (GstPad * srcpad, GstPad * sinkpad)
2129 {
2130   return gst_pad_link_full (srcpad, sinkpad, GST_PAD_LINK_CHECK_DEFAULT);
2131 }
2132
2133 static void
2134 gst_pad_set_pad_template (GstPad * pad, GstPadTemplate * templ)
2135 {
2136   GstPadTemplate **template_p;
2137
2138   /* this function would need checks if it weren't static */
2139
2140   GST_OBJECT_LOCK (pad);
2141   template_p = &pad->padtemplate;
2142   gst_object_replace ((GstObject **) template_p, (GstObject *) templ);
2143   GST_OBJECT_UNLOCK (pad);
2144
2145   if (templ)
2146     gst_pad_template_pad_created (templ, pad);
2147 }
2148
2149 /**
2150  * gst_pad_get_pad_template:
2151  * @pad: a #GstPad.
2152  *
2153  * Gets the template for @pad.
2154  *
2155  * Returns: (transfer full): the #GstPadTemplate from which this pad was
2156  *     instantiated, or %NULL if this pad has no template. Unref after
2157  *     usage.
2158  */
2159 GstPadTemplate *
2160 gst_pad_get_pad_template (GstPad * pad)
2161 {
2162   GstPadTemplate *templ;
2163
2164   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2165
2166   templ = GST_PAD_PAD_TEMPLATE (pad);
2167
2168   return (templ ? gst_object_ref (templ) : NULL);
2169 }
2170
2171 /**
2172  * gst_pad_has_current_caps:
2173  * @pad: a  #GstPad to check
2174  *
2175  * Check if @pad has caps set on it with a #GST_EVENT_CAPS event.
2176  *
2177  * Returns: TRUE when @pad has caps associated with it.
2178  */
2179 gboolean
2180 gst_pad_has_current_caps (GstPad * pad)
2181 {
2182   gboolean result;
2183   GstCaps *caps;
2184
2185   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2186
2187   GST_OBJECT_LOCK (pad);
2188   caps = get_pad_caps (pad);
2189   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2190       "check current pad caps %" GST_PTR_FORMAT, caps);
2191   result = (caps != NULL);
2192   GST_OBJECT_UNLOCK (pad);
2193
2194   return result;
2195 }
2196
2197 /**
2198  * gst_pad_get_current_caps:
2199  * @pad: a  #GstPad to get the current capabilities of.
2200  *
2201  * Gets the capabilities currently configured on @pad with the last
2202  * #GST_EVENT_CAPS event.
2203  *
2204  * Returns: the current caps of the pad with incremented ref-count.
2205  */
2206 GstCaps *
2207 gst_pad_get_current_caps (GstPad * pad)
2208 {
2209   GstCaps *result;
2210
2211   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2212
2213   GST_OBJECT_LOCK (pad);
2214   if ((result = get_pad_caps (pad)))
2215     gst_caps_ref (result);
2216   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2217       "get current pad caps %" GST_PTR_FORMAT, result);
2218   GST_OBJECT_UNLOCK (pad);
2219
2220   return result;
2221 }
2222
2223 /**
2224  * gst_pad_set_caps:
2225  * @pad: a  #GstPad to set the capabilities of.
2226  * @caps: (transfer none): a #GstCaps to set.
2227  *
2228  * Sets the capabilities of this pad. The caps must be fixed. Any previous
2229  * caps on the pad will be unreffed. This function refs the caps so you should
2230  * unref if as soon as you don't need it anymore.
2231  * It is possible to set NULL caps, which will make the pad unnegotiated
2232  * again.
2233  *
2234  * Returns: TRUE if the caps could be set. FALSE if the caps were not fixed
2235  * or bad parameters were provided to this function.
2236  *
2237  * MT safe.
2238  */
2239 gboolean
2240 gst_pad_set_caps (GstPad * pad, GstCaps * caps)
2241 {
2242   GstEvent *event;
2243   gboolean res = TRUE;
2244
2245   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2246   g_return_val_if_fail (caps != NULL && gst_caps_is_fixed (caps), FALSE);
2247
2248   event = gst_event_new_caps (caps);
2249
2250   if (GST_PAD_IS_SRC (pad))
2251     res = gst_pad_push_event (pad, event);
2252   else
2253     res = gst_pad_send_event (pad, event);
2254
2255   return res;
2256 }
2257
2258 /**
2259  * gst_pad_get_pad_template_caps:
2260  * @pad: a #GstPad to get the template capabilities from.
2261  *
2262  * Gets the capabilities for @pad's template.
2263  *
2264  * Returns: (transfer full): the #GstCaps of this pad template.
2265  * Unref after usage.
2266  */
2267 GstCaps *
2268 gst_pad_get_pad_template_caps (GstPad * pad)
2269 {
2270   static GstStaticCaps anycaps = GST_STATIC_CAPS ("ANY");
2271
2272   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2273
2274   if (GST_PAD_PAD_TEMPLATE (pad))
2275     return gst_pad_template_get_caps (GST_PAD_PAD_TEMPLATE (pad));
2276
2277   return gst_static_caps_get (&anycaps);
2278 }
2279
2280 /**
2281  * gst_pad_get_peer:
2282  * @pad: a #GstPad to get the peer of.
2283  *
2284  * Gets the peer of @pad. This function refs the peer pad so
2285  * you need to unref it after use.
2286  *
2287  * Returns: (transfer full): the peer #GstPad. Unref after usage.
2288  *
2289  * MT safe.
2290  */
2291 GstPad *
2292 gst_pad_get_peer (GstPad * pad)
2293 {
2294   GstPad *result;
2295
2296   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2297
2298   GST_OBJECT_LOCK (pad);
2299   result = GST_PAD_PEER (pad);
2300   if (result)
2301     gst_object_ref (result);
2302   GST_OBJECT_UNLOCK (pad);
2303
2304   return result;
2305 }
2306
2307 /**
2308  * gst_pad_get_allowed_caps:
2309  * @pad: a #GstPad.
2310  *
2311  * Gets the capabilities of the allowed media types that can flow through
2312  * @pad and its peer.
2313  *
2314  * The allowed capabilities is calculated as the intersection of the results of
2315  * calling gst_pad_query_caps() on @pad and its peer. The caller owns a reference
2316  * on the resulting caps.
2317  *
2318  * Returns: (transfer full): the allowed #GstCaps of the pad link. Unref the
2319  *     caps when you no longer need it. This function returns NULL when @pad
2320  *     has no peer.
2321  *
2322  * MT safe.
2323  */
2324 GstCaps *
2325 gst_pad_get_allowed_caps (GstPad * pad)
2326 {
2327   GstCaps *mycaps;
2328   GstCaps *caps;
2329   GstCaps *peercaps;
2330   GstPad *peer;
2331
2332   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2333
2334   GST_OBJECT_LOCK (pad);
2335   peer = GST_PAD_PEER (pad);
2336   if (G_UNLIKELY (peer == NULL))
2337     goto no_peer;
2338
2339   GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "getting allowed caps");
2340
2341   gst_object_ref (peer);
2342   GST_OBJECT_UNLOCK (pad);
2343   mycaps = gst_pad_query_caps (pad, NULL);
2344
2345   peercaps = gst_pad_query_caps (peer, NULL);
2346   gst_object_unref (peer);
2347
2348   caps = gst_caps_intersect (mycaps, peercaps);
2349   gst_caps_unref (peercaps);
2350   gst_caps_unref (mycaps);
2351
2352   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "allowed caps %" GST_PTR_FORMAT,
2353       caps);
2354
2355   return caps;
2356
2357 no_peer:
2358   {
2359     GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "no peer");
2360     GST_OBJECT_UNLOCK (pad);
2361
2362     return NULL;
2363   }
2364 }
2365
2366 /**
2367  * gst_pad_iterate_internal_links_default:
2368  * @pad: the #GstPad to get the internal links of.
2369  * @parent: the parent of @pad or NULL
2370  *
2371  * Iterate the list of pads to which the given pad is linked to inside of
2372  * the parent element.
2373  * This is the default handler, and thus returns an iterator of all of the
2374  * pads inside the parent element with opposite direction.
2375  *
2376  * The caller must free this iterator after use with gst_iterator_free().
2377  *
2378  * Returns: a #GstIterator of #GstPad, or NULL if @pad has no parent. Unref each
2379  * returned pad with gst_object_unref().
2380  *
2381  * Since: 0.10.21
2382  */
2383 GstIterator *
2384 gst_pad_iterate_internal_links_default (GstPad * pad, GstObject * parent)
2385 {
2386   GstIterator *res;
2387   GList **padlist;
2388   guint32 *cookie;
2389   GMutex *lock;
2390   gpointer owner;
2391   GstElement *eparent;
2392
2393   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2394
2395   if (parent != NULL && GST_IS_ELEMENT (parent)) {
2396     eparent = GST_ELEMENT_CAST (gst_object_ref (parent));
2397   } else {
2398     GST_OBJECT_LOCK (pad);
2399     eparent = GST_PAD_PARENT (pad);
2400     if (!eparent || !GST_IS_ELEMENT (eparent))
2401       goto no_parent;
2402
2403     gst_object_ref (eparent);
2404     GST_OBJECT_UNLOCK (pad);
2405   }
2406
2407   if (pad->direction == GST_PAD_SRC)
2408     padlist = &eparent->sinkpads;
2409   else
2410     padlist = &eparent->srcpads;
2411
2412   GST_DEBUG_OBJECT (pad, "Making iterator");
2413
2414   cookie = &eparent->pads_cookie;
2415   owner = eparent;
2416   lock = GST_OBJECT_GET_LOCK (eparent);
2417
2418   res = gst_iterator_new_list (GST_TYPE_PAD,
2419       lock, cookie, padlist, (GObject *) owner, NULL);
2420
2421   gst_object_unref (owner);
2422
2423   return res;
2424
2425   /* ERRORS */
2426 no_parent:
2427   {
2428     GST_OBJECT_UNLOCK (pad);
2429     GST_DEBUG_OBJECT (pad, "no parent element");
2430     return NULL;
2431   }
2432 }
2433
2434 /**
2435  * gst_pad_iterate_internal_links:
2436  * @pad: the GstPad to get the internal links of.
2437  *
2438  * Gets an iterator for the pads to which the given pad is linked to inside
2439  * of the parent element.
2440  *
2441  * Each #GstPad element yielded by the iterator will have its refcount increased,
2442  * so unref after use.
2443  *
2444  * Free-function: gst_iterator_free
2445  *
2446  * Returns: (transfer full): a new #GstIterator of #GstPad or %NULL when the
2447  *     pad does not have an iterator function configured. Use
2448  *     gst_iterator_free() after usage.
2449  *
2450  * Since: 0.10.21
2451  */
2452 GstIterator *
2453 gst_pad_iterate_internal_links (GstPad * pad)
2454 {
2455   GstIterator *res = NULL;
2456   GstObject *parent;
2457
2458   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2459
2460   GST_OBJECT_LOCK (pad);
2461   ACQUIRE_PARENT (pad, parent, no_parent);
2462   GST_OBJECT_UNLOCK (pad);
2463
2464   if (GST_PAD_ITERINTLINKFUNC (pad))
2465     res = GST_PAD_ITERINTLINKFUNC (pad) (pad, parent);
2466
2467   RELEASE_PARENT (parent);
2468
2469   return res;
2470
2471   /* ERRORS */
2472 no_parent:
2473   {
2474     GST_DEBUG_OBJECT (pad, "no parent");
2475     GST_OBJECT_UNLOCK (pad);
2476     return FALSE;
2477   }
2478 }
2479
2480 /**
2481  * gst_pad_forward:
2482  * @pad: a #GstPad
2483  * @forward: a #GstPadForwardFunction
2484  * @user_data: user data passed to @forward
2485  *
2486  * Calls @forward for all internally linked pads of @pad. This function deals with
2487  * dynamically changing internal pads and will make sure that the @forward
2488  * function is only called once for each pad.
2489  *
2490  * When @forward returns TRUE, no further pads will be processed.
2491  *
2492  * Returns: TRUE if one of the dispatcher functions returned TRUE.
2493  */
2494 gboolean
2495 gst_pad_forward (GstPad * pad, GstPadForwardFunction forward,
2496     gpointer user_data)
2497 {
2498   gboolean result = FALSE;
2499   GstIterator *iter;
2500   gboolean done = FALSE;
2501   GValue item = { 0, };
2502   GList *pushed_pads = NULL;
2503
2504   iter = gst_pad_iterate_internal_links (pad);
2505
2506   if (!iter)
2507     goto no_iter;
2508
2509   while (!done) {
2510     switch (gst_iterator_next (iter, &item)) {
2511       case GST_ITERATOR_OK:
2512       {
2513         GstPad *intpad;
2514
2515         intpad = g_value_get_object (&item);
2516
2517         /* if already pushed, skip. FIXME, find something faster to tag pads */
2518         if (intpad == NULL || g_list_find (pushed_pads, intpad)) {
2519           g_value_reset (&item);
2520           break;
2521         }
2522
2523         GST_LOG_OBJECT (pad, "calling forward function on pad %s:%s",
2524             GST_DEBUG_PAD_NAME (intpad));
2525         done = result = forward (intpad, user_data);
2526
2527         pushed_pads = g_list_prepend (pushed_pads, intpad);
2528
2529         g_value_reset (&item);
2530         break;
2531       }
2532       case GST_ITERATOR_RESYNC:
2533         /* We don't reset the result here because we don't push the event
2534          * again on pads that got the event already and because we need
2535          * to consider the result of the previous pushes */
2536         gst_iterator_resync (iter);
2537         break;
2538       case GST_ITERATOR_ERROR:
2539         GST_ERROR_OBJECT (pad, "Could not iterate over internally linked pads");
2540         done = TRUE;
2541         break;
2542       case GST_ITERATOR_DONE:
2543         done = TRUE;
2544         break;
2545     }
2546   }
2547   g_value_unset (&item);
2548   gst_iterator_free (iter);
2549
2550   g_list_free (pushed_pads);
2551
2552 no_iter:
2553   return result;
2554 }
2555
2556 typedef struct
2557 {
2558   GstEvent *event;
2559   gboolean result;
2560   gboolean dispatched;
2561 } EventData;
2562
2563 static gboolean
2564 event_forward_func (GstPad * pad, EventData * data)
2565 {
2566   /* for each pad we send to, we should ref the event; it's up
2567    * to downstream to unref again when handled. */
2568   GST_LOG_OBJECT (pad, "Reffing and pushing event %p (%s) to %s:%s",
2569       data->event, GST_EVENT_TYPE_NAME (data->event), GST_DEBUG_PAD_NAME (pad));
2570
2571   data->result |= gst_pad_push_event (pad, gst_event_ref (data->event));
2572
2573   data->dispatched = TRUE;
2574
2575   /* don't stop */
2576   return FALSE;
2577 }
2578
2579 /**
2580  * gst_pad_event_default:
2581  * @pad: a #GstPad to call the default event handler on.
2582  * @parent: the parent of @pad or NULL
2583  * @event: (transfer full): the #GstEvent to handle.
2584  *
2585  * Invokes the default event handler for the given pad.
2586  *
2587  * The EOS event will pause the task associated with @pad before it is forwarded
2588  * to all internally linked pads,
2589  *
2590  * The the event is sent to all pads internally linked to @pad. This function
2591  * takes ownership of @event.
2592  *
2593  * Returns: TRUE if the event was sent successfully.
2594  */
2595 gboolean
2596 gst_pad_event_default (GstPad * pad, GstObject * parent, GstEvent * event)
2597 {
2598   gboolean result, forward = TRUE;
2599
2600   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2601   g_return_val_if_fail (event != NULL, FALSE);
2602
2603   GST_LOG_OBJECT (pad, "default event handler");
2604
2605   switch (GST_EVENT_TYPE (event)) {
2606     case GST_EVENT_EOS:
2607     {
2608       GST_DEBUG_OBJECT (pad, "pausing task because of eos");
2609       gst_pad_pause_task (pad);
2610       break;
2611     }
2612     case GST_EVENT_CAPS:
2613       forward = GST_PAD_IS_PROXY_CAPS (pad);
2614       result = TRUE;
2615       break;
2616     default:
2617       break;
2618   }
2619
2620   if (forward) {
2621     EventData data;
2622
2623     data.event = event;
2624     data.dispatched = FALSE;
2625     data.result = FALSE;
2626
2627     gst_pad_forward (pad, (GstPadForwardFunction) event_forward_func, &data);
2628
2629     /* for sinkpads without a parent element or without internal links, nothing
2630      * will be dispatched but we still want to return TRUE. */
2631     if (data.dispatched)
2632       result = data.result;
2633     else
2634       result = TRUE;
2635   }
2636
2637   gst_event_unref (event);
2638
2639   return result;
2640 }
2641
2642 /* Default accept caps implementation just checks against
2643  * the allowed caps for the pad */
2644 static gboolean
2645 gst_pad_query_accept_caps_default (GstPad * pad, GstQuery * query)
2646 {
2647   /* get the caps and see if it intersects to something not empty */
2648   GstCaps *caps, *allowed;
2649   gboolean result;
2650
2651   GST_DEBUG_OBJECT (pad, "query accept-caps %" GST_PTR_FORMAT, query);
2652
2653   /* first forward the query to internally linked pads when we are dealing with
2654    * a PROXY CAPS */
2655   if (GST_PAD_IS_PROXY_CAPS (pad)) {
2656     if ((result = gst_pad_proxy_query_accept_caps (pad, query))) {
2657       goto done;
2658     }
2659   }
2660
2661   allowed = gst_pad_query_caps (pad, NULL);
2662   gst_query_parse_accept_caps (query, &caps);
2663
2664   if (allowed) {
2665     GST_DEBUG_OBJECT (pad, "allowed caps %" GST_PTR_FORMAT, allowed);
2666     result = gst_caps_is_subset (caps, allowed);
2667     gst_caps_unref (allowed);
2668   } else {
2669     GST_DEBUG_OBJECT (pad, "no caps allowed on the pad");
2670     result = FALSE;
2671   }
2672   gst_query_set_accept_caps_result (query, result);
2673
2674 done:
2675   return TRUE;
2676 }
2677
2678 /* Default caps implementation */
2679 static gboolean
2680 gst_pad_query_caps_default (GstPad * pad, GstQuery * query)
2681 {
2682   GstCaps *result = NULL, *filter;
2683   GstPadTemplate *templ;
2684   gboolean fixed_caps;
2685
2686   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "get pad caps");
2687
2688   gst_query_parse_caps (query, &filter);
2689
2690   /* first try to proxy if we must */
2691   if (GST_PAD_IS_PROXY_CAPS (pad)) {
2692     if ((gst_pad_proxy_query_caps (pad, query))) {
2693       gst_query_parse_caps_result (query, &result);
2694       goto filter_done;
2695     }
2696   }
2697
2698   /* no proxy or it failed, do default handling */
2699   fixed_caps = GST_PAD_IS_FIXED_CAPS (pad);
2700
2701   GST_OBJECT_LOCK (pad);
2702   if (fixed_caps) {
2703     /* fixed caps, try the negotiated caps first */
2704     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "fixed pad caps: trying pad caps");
2705     if ((result = get_pad_caps (pad)))
2706       goto filter_done_unlock;
2707   }
2708
2709   if ((templ = GST_PAD_PAD_TEMPLATE (pad))) {
2710     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "trying pad template caps");
2711     if ((result = GST_PAD_TEMPLATE_CAPS (templ)))
2712       goto filter_done_unlock;
2713   }
2714
2715   if (!fixed_caps) {
2716     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2717         "non-fixed pad caps: trying pad caps");
2718     /* non fixed caps, try the negotiated caps */
2719     if ((result = get_pad_caps (pad)))
2720       goto filter_done_unlock;
2721   }
2722   GST_OBJECT_UNLOCK (pad);
2723
2724   /* this almost never happens */
2725   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "pad has no caps");
2726   result = gst_caps_new_empty ();
2727
2728   goto done;
2729
2730 filter_done_unlock:
2731   GST_OBJECT_UNLOCK (pad);
2732
2733 filter_done:
2734   /* run the filter on the result */
2735   if (filter) {
2736     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2737         "using caps %p %" GST_PTR_FORMAT " with filter %p %"
2738         GST_PTR_FORMAT, result, result, filter, filter);
2739     result = gst_caps_intersect_full (filter, result, GST_CAPS_INTERSECT_FIRST);
2740     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "result %p %" GST_PTR_FORMAT,
2741         result, result);
2742   } else {
2743     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2744         "using caps %p %" GST_PTR_FORMAT, result, result);
2745     result = gst_caps_ref (result);
2746   }
2747
2748 done:
2749   gst_query_set_caps_result (query, result);
2750   gst_caps_unref (result);
2751
2752   return TRUE;
2753 }
2754
2755 /**
2756  * gst_pad_query_default:
2757  * @pad: a #GstPad to call the default query handler on.
2758  * @parent: the parent of @pad or NULL
2759  * @query: (transfer none): the #GstQuery to handle.
2760  *
2761  * Invokes the default query handler for the given pad.
2762  * The query is sent to all pads internally linked to @pad. Note that
2763  * if there are many possible sink pads that are internally linked to
2764  * @pad, only one will be sent the query.
2765  * Multi-sinkpad elements should implement custom query handlers.
2766  *
2767  * Returns: TRUE if the query was performed successfully.
2768  */
2769 gboolean
2770 gst_pad_query_default (GstPad * pad, GstObject * parent, GstQuery * query)
2771 {
2772   gboolean forward, ret = FALSE;
2773
2774   switch (GST_QUERY_TYPE (query)) {
2775     case GST_QUERY_SCHEDULING:
2776       forward = FALSE;
2777       break;
2778     case GST_QUERY_ALLOCATION:
2779       forward = GST_PAD_IS_PROXY_ALLOCATION (pad);
2780       break;
2781     case GST_QUERY_ACCEPT_CAPS:
2782       ret = gst_pad_query_accept_caps_default (pad, query);
2783       forward = FALSE;
2784       break;
2785     case GST_QUERY_CAPS:
2786       ret = gst_pad_query_caps_default (pad, query);
2787       forward = FALSE;
2788       break;
2789     case GST_QUERY_POSITION:
2790     case GST_QUERY_SEEKING:
2791     case GST_QUERY_FORMATS:
2792     case GST_QUERY_LATENCY:
2793     case GST_QUERY_JITTER:
2794     case GST_QUERY_RATE:
2795     case GST_QUERY_CONVERT:
2796     default:
2797       forward = TRUE;
2798       break;
2799   }
2800
2801   if (forward) {
2802     ret = gst_pad_forward
2803         (pad, (GstPadForwardFunction) gst_pad_peer_query, query);
2804   }
2805   return ret;
2806 }
2807
2808 static void
2809 probe_hook_marshal (GHook * hook, ProbeMarshall * data)
2810 {
2811   GstPad *pad = data->pad;
2812   GstPadProbeInfo *info = data->info;
2813   GstPadProbeType type, flags;
2814   GstPadProbeCallback callback;
2815   GstPadProbeReturn ret;
2816
2817   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
2818       "hook %lu, cookie %u checking", hook->hook_id, PROBE_COOKIE (hook));
2819
2820   /* if we have called this callback, do nothing */
2821   if (PROBE_COOKIE (hook) == data->cookie) {
2822     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
2823         "hook %lu, cookie %u already called", hook->hook_id,
2824         PROBE_COOKIE (hook));
2825     return;
2826   }
2827
2828   PROBE_COOKIE (hook) = data->cookie;
2829
2830   flags = hook->flags >> G_HOOK_FLAG_USER_SHIFT;
2831   type = info->type;
2832
2833   /* one of the data types */
2834   if ((flags & GST_PAD_PROBE_TYPE_ALL_BOTH & type) == 0)
2835     goto no_match;
2836   /* one of the scheduling types */
2837   if ((flags & GST_PAD_PROBE_TYPE_SCHEDULING & type) == 0)
2838     goto no_match;
2839   /* one of the blocking types must match */
2840   if ((type & GST_PAD_PROBE_TYPE_BLOCKING) &&
2841       (flags & GST_PAD_PROBE_TYPE_BLOCKING & type) == 0)
2842     goto no_match;
2843   /* only probes that have GST_PAD_PROBE_TYPE_EVENT_FLUSH set */
2844   if ((type & GST_PAD_PROBE_TYPE_EVENT_FLUSH) &&
2845       (flags & GST_PAD_PROBE_TYPE_EVENT_FLUSH & type) == 0)
2846     goto no_match;
2847
2848   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
2849       "hook %lu with flags 0x%08x matches", hook->hook_id, flags);
2850
2851   callback = (GstPadProbeCallback) hook->func;
2852   if (callback == NULL)
2853     return;
2854
2855   info->id = hook->hook_id;
2856
2857   GST_OBJECT_UNLOCK (pad);
2858
2859   ret = callback (pad, info, hook->data);
2860
2861   GST_OBJECT_LOCK (pad);
2862   data->marshalled = TRUE;
2863
2864   switch (ret) {
2865     case GST_PAD_PROBE_REMOVE:
2866       /* remove the probe */
2867       GST_DEBUG_OBJECT (pad, "asked to remove hook");
2868       cleanup_hook (pad, hook);
2869       break;
2870     case GST_PAD_PROBE_DROP:
2871       /* need to drop the data, make sure other probes don't get called
2872        * anymore */
2873       GST_DEBUG_OBJECT (pad, "asked to drop item");
2874       info->type = GST_PAD_PROBE_TYPE_INVALID;
2875       data->dropped = TRUE;
2876       break;
2877     case GST_PAD_PROBE_PASS:
2878       /* inform the pad block to let things pass */
2879       GST_DEBUG_OBJECT (pad, "asked to pass item");
2880       data->pass = TRUE;
2881       break;
2882     default:
2883       GST_DEBUG_OBJECT (pad, "probe returned %d", ret);
2884       break;
2885   }
2886   return;
2887
2888 no_match:
2889   {
2890     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
2891         "hook %lu with flags 0x%08x does not match %08x", hook->hook_id,
2892         flags, info->type);
2893     return;
2894   }
2895 }
2896
2897 #define PROBE_PRE_PULL(pad,mask,data,offs,size,label,probed,defaultval)    \
2898   G_STMT_START {                                                \
2899     if (G_UNLIKELY (pad->num_probes)) {                         \
2900       /* we start with passing NULL as the data item */         \
2901       GstPadProbeInfo info = { mask, 0, NULL, offs, size };     \
2902       ret = do_probe_callbacks (pad, &info, defaultval);        \
2903       /* store the possibly updated data item */                \
2904       data = GST_PAD_PROBE_INFO_DATA (&info);                   \
2905       /* if something went wrong, exit */                       \
2906       if (G_UNLIKELY (ret != defaultval && ret != GST_FLOW_OK)) \
2907         goto label;                                             \
2908       /* otherwise check if the probe retured data */           \
2909       if (G_UNLIKELY (data != NULL))                            \
2910         goto probed;                                            \
2911     }                                                           \
2912   } G_STMT_END
2913
2914
2915 /* a probe that does not take or return any data */
2916 #define PROBE_NO_DATA(pad,mask,label,defaultval)                \
2917   G_STMT_START {                                                \
2918     if (G_UNLIKELY (pad->num_probes)) {                         \
2919       /* pass NULL as the data item */                          \
2920       GstPadProbeInfo info = { mask, 0, NULL, 0, 0 };           \
2921       ret = do_probe_callbacks (pad, &info, defaultval);        \
2922       if (G_UNLIKELY (ret != defaultval && ret != GST_FLOW_OK)) \
2923         goto label;                                             \
2924     }                                                           \
2925   } G_STMT_END
2926
2927 #define PROBE_FULL(pad,mask,data,offs,size,label,defaultval)    \
2928   G_STMT_START {                                                \
2929     if (G_UNLIKELY (pad->num_probes)) {                         \
2930       GstPadProbeInfo info = { mask, 0, data, offs, size };     \
2931       ret = do_probe_callbacks (pad, &info, defaultval);        \
2932       data = GST_PAD_PROBE_INFO_DATA (&info);                   \
2933       if (G_UNLIKELY (ret != defaultval && ret != GST_FLOW_OK)) \
2934         goto label;                                             \
2935     }                                                           \
2936   } G_STMT_END
2937
2938 #define PROBE_PUSH(pad,mask,data,label)                         \
2939   PROBE_FULL(pad, mask, data, -1, -1, label, GST_FLOW_OK);
2940 #define PROBE_PULL(pad,mask,data,offs,size,label)               \
2941   PROBE_FULL(pad, mask, data, offs, size, label, GST_FLOW_OK);
2942
2943 static GstFlowReturn
2944 do_probe_callbacks (GstPad * pad, GstPadProbeInfo * info,
2945     GstFlowReturn defaultval)
2946 {
2947   ProbeMarshall data;
2948   guint cookie;
2949   gboolean is_block;
2950
2951   data.pad = pad;
2952   data.info = info;
2953   data.pass = FALSE;
2954   data.marshalled = FALSE;
2955   data.dropped = FALSE;
2956   data.cookie = ++pad->priv->probe_cookie;
2957
2958   is_block =
2959       (info->type & GST_PAD_PROBE_TYPE_BLOCK) == GST_PAD_PROBE_TYPE_BLOCK;
2960
2961 again:
2962   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
2963       "do probes cookie %u", data.cookie);
2964   cookie = pad->priv->probe_list_cookie;
2965
2966   g_hook_list_marshal (&pad->probes, TRUE,
2967       (GHookMarshaller) probe_hook_marshal, &data);
2968
2969   /* if the list changed, call the new callbacks (they will not have their
2970    * cookie set to data.cookie */
2971   if (cookie != pad->priv->probe_list_cookie) {
2972     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
2973         "probe list changed, restarting");
2974     goto again;
2975   }
2976
2977   /* the first item that dropped will stop the hooks and then we drop here */
2978   if (data.dropped)
2979     goto dropped;
2980
2981   /* if no handler matched and we are blocking, let the item pass */
2982   if (!data.marshalled && is_block)
2983     goto passed;
2984
2985   /* At this point, all handlers returned either OK or PASS. If one handler
2986    * returned PASS, let the item pass */
2987   if (data.pass)
2988     goto passed;
2989
2990   if (is_block) {
2991     while (GST_PAD_IS_BLOCKED (pad)) {
2992       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
2993           "we are blocked %d times", pad->num_blocked);
2994
2995       /* we might have released the lock */
2996       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
2997         goto flushing;
2998
2999       /* now we block the streaming thread. It can be unlocked when we
3000        * deactivate the pad (which will also set the FLUSHING flag) or
3001        * when the pad is unblocked. A flushing event will also unblock
3002        * the pad after setting the FLUSHING flag. */
3003       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3004           "Waiting to be unblocked or set flushing");
3005       GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_BLOCKING);
3006       GST_PAD_BLOCK_WAIT (pad);
3007       GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_BLOCKING);
3008       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "We got unblocked");
3009
3010       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
3011         goto flushing;
3012     }
3013   }
3014
3015   return defaultval;
3016
3017   /* ERRORS */
3018 flushing:
3019   {
3020     GST_DEBUG_OBJECT (pad, "pad is flushing");
3021     return GST_FLOW_WRONG_STATE;
3022   }
3023 dropped:
3024   {
3025     GST_DEBUG_OBJECT (pad, "data is dropped");
3026     return GST_FLOW_CUSTOM_SUCCESS;
3027   }
3028 passed:
3029   {
3030     /* FIXME : Should we return FLOW_OK or the defaultval ?? */
3031     GST_DEBUG_OBJECT (pad, "data is passed");
3032     return GST_FLOW_OK;
3033   }
3034 }
3035
3036 /* pad offsets */
3037
3038 /**
3039  * gst_pad_get_offset:
3040  * @pad: a #GstPad
3041  *
3042  * Get the offset applied to the running time of @pad. @pad has to be a source
3043  * pad.
3044  *
3045  * Returns: the offset.
3046  */
3047 gint64
3048 gst_pad_get_offset (GstPad * pad)
3049 {
3050   gint64 result;
3051
3052   g_return_val_if_fail (GST_IS_PAD (pad), 0);
3053
3054   GST_OBJECT_LOCK (pad);
3055   result = pad->offset;
3056   GST_OBJECT_UNLOCK (pad);
3057
3058   return result;
3059 }
3060
3061 /**
3062  * gst_pad_set_offset:
3063  * @pad: a #GstPad
3064  * @offset: the offset
3065  *
3066  * Set the offset that will be applied to the running time of @pad.
3067  */
3068 void
3069 gst_pad_set_offset (GstPad * pad, gint64 offset)
3070 {
3071   PadEvent *ev;
3072
3073   g_return_if_fail (GST_IS_PAD (pad));
3074
3075   GST_OBJECT_LOCK (pad);
3076   /* if nothing changed, do nothing */
3077   if (pad->offset == offset)
3078     goto done;
3079
3080   pad->offset = offset;
3081   GST_DEBUG_OBJECT (pad, "changed offset to %" G_GINT64_FORMAT, offset);
3082
3083   /* sinkpads will apply their offset the next time a segment
3084    * event is received. */
3085   if (GST_PAD_IS_SINK (pad))
3086     goto done;
3087
3088   /* resend the last segment event on next buffer push */
3089   if ((ev = find_event_by_type (pad, GST_EVENT_SEGMENT, 0))) {
3090     ev->received = FALSE;
3091     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
3092   }
3093
3094 done:
3095   GST_OBJECT_UNLOCK (pad);
3096 }
3097
3098
3099 /**
3100  * gst_pad_query:
3101  * @pad: a #GstPad to invoke the default query on.
3102  * @query: (transfer none): the #GstQuery to perform.
3103  *
3104  * Dispatches a query to a pad. The query should have been allocated by the
3105  * caller via one of the type-specific allocation functions. The element that
3106  * the pad belongs to is responsible for filling the query with an appropriate
3107  * response, which should then be parsed with a type-specific query parsing
3108  * function.
3109  *
3110  * Again, the caller is responsible for both the allocation and deallocation of
3111  * the query structure.
3112  *
3113  * Please also note that some queries might need a running pipeline to work.
3114  *
3115  * Returns: TRUE if the query could be performed.
3116  */
3117 gboolean
3118 gst_pad_query (GstPad * pad, GstQuery * query)
3119 {
3120   GstObject *parent;
3121   gboolean res;
3122   GstPadQueryFunction func;
3123   GstPadProbeType type;
3124   GstFlowReturn ret;
3125
3126   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
3127   g_return_val_if_fail (GST_IS_QUERY (query), FALSE);
3128
3129   GST_DEBUG_OBJECT (pad, "sending query %p (%s)", query,
3130       GST_QUERY_TYPE_NAME (query));
3131
3132   if (GST_PAD_IS_SRC (pad))
3133     type = GST_PAD_PROBE_TYPE_QUERY_UPSTREAM;
3134   else
3135     type = GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM;
3136
3137   GST_OBJECT_LOCK (pad);
3138   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH |
3139       GST_PAD_PROBE_TYPE_BLOCK, query, probe_stopped);
3140   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH, query, probe_stopped);
3141
3142   ACQUIRE_PARENT (pad, parent, no_parent);
3143   GST_OBJECT_UNLOCK (pad);
3144
3145   if ((func = GST_PAD_QUERYFUNC (pad)) == NULL)
3146     goto no_func;
3147
3148   res = func (pad, parent, query);
3149
3150   RELEASE_PARENT (parent);
3151
3152   GST_DEBUG_OBJECT (pad, "sent query %p (%s), result %d", query,
3153       GST_QUERY_TYPE_NAME (query), res);
3154
3155   if (res != TRUE)
3156     goto query_failed;
3157
3158   GST_OBJECT_LOCK (pad);
3159   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PULL, query, probe_stopped);
3160   GST_OBJECT_UNLOCK (pad);
3161
3162   return res;
3163
3164   /* ERRORS */
3165 no_parent:
3166   {
3167     GST_DEBUG_OBJECT (pad, "had no parent");
3168     GST_OBJECT_UNLOCK (pad);
3169     return FALSE;
3170   }
3171 no_func:
3172   {
3173     GST_DEBUG_OBJECT (pad, "had no query function");
3174     RELEASE_PARENT (parent);
3175     return FALSE;
3176   }
3177 query_failed:
3178   {
3179     GST_DEBUG_OBJECT (pad, "query failed");
3180     return FALSE;
3181   }
3182 probe_stopped:
3183   {
3184     GST_DEBUG_OBJECT (pad, "probe stopped: %s", gst_flow_get_name (ret));
3185     GST_OBJECT_UNLOCK (pad);
3186     return FALSE;
3187   }
3188 }
3189
3190 /**
3191  * gst_pad_peer_query:
3192  * @pad: a #GstPad to invoke the peer query on.
3193  * @query: (transfer none): the #GstQuery to perform.
3194  *
3195  * Performs gst_pad_query() on the peer of @pad.
3196  *
3197  * The caller is responsible for both the allocation and deallocation of
3198  * the query structure.
3199  *
3200  * Returns: TRUE if the query could be performed. This function returns %FALSE
3201  * if @pad has no peer.
3202  *
3203  * Since: 0.10.15
3204  */
3205 gboolean
3206 gst_pad_peer_query (GstPad * pad, GstQuery * query)
3207 {
3208   GstPad *peerpad;
3209   GstPadProbeType type;
3210   gboolean res;
3211   GstFlowReturn ret;
3212
3213   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
3214   g_return_val_if_fail (GST_IS_QUERY (query), FALSE);
3215
3216   if (GST_PAD_IS_SRC (pad))
3217     type = GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM;
3218   else
3219     type = GST_PAD_PROBE_TYPE_QUERY_UPSTREAM;
3220
3221   GST_DEBUG_OBJECT (pad, "peer query %p (%s)", query,
3222       GST_QUERY_TYPE_NAME (query));
3223
3224   GST_OBJECT_LOCK (pad);
3225   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH |
3226       GST_PAD_PROBE_TYPE_BLOCK, query, probe_stopped);
3227   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH, query, probe_stopped);
3228
3229   peerpad = GST_PAD_PEER (pad);
3230   if (G_UNLIKELY (peerpad == NULL))
3231     goto no_peer;
3232
3233   gst_object_ref (peerpad);
3234   GST_OBJECT_UNLOCK (pad);
3235
3236   res = gst_pad_query (peerpad, query);
3237
3238   gst_object_unref (peerpad);
3239
3240   if (res != TRUE)
3241     goto query_failed;
3242
3243   GST_OBJECT_LOCK (pad);
3244   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PULL, query, probe_stopped);
3245   GST_OBJECT_UNLOCK (pad);
3246
3247   return res;
3248
3249   /* ERRORS */
3250 no_peer:
3251   {
3252     GST_WARNING_OBJECT (pad, "pad has no peer");
3253     GST_OBJECT_UNLOCK (pad);
3254     return FALSE;
3255   }
3256 query_failed:
3257   {
3258     GST_DEBUG_OBJECT (pad, "query failed");
3259     return FALSE;
3260   }
3261 probe_stopped:
3262   {
3263     GST_DEBUG_OBJECT (pad, "probe stopped: %s", gst_flow_get_name (ret));
3264     GST_OBJECT_UNLOCK (pad);
3265     return FALSE;
3266   }
3267 }
3268
3269 /**********************************************************************
3270  * Data passing functions
3271  */
3272
3273 static gboolean
3274 push_sticky (GstPad * pad, PadEvent * ev, gpointer user_data)
3275 {
3276   GstFlowReturn *data = user_data;
3277   gboolean stored;
3278
3279   if (ev->received) {
3280     GST_DEBUG_OBJECT (pad, "event %s was already received",
3281         GST_EVENT_TYPE_NAME (ev->event));
3282     return TRUE;
3283   }
3284   GST_OBJECT_UNLOCK (pad);
3285
3286   *data = gst_pad_push_event_unchecked (pad, gst_event_ref (ev->event),
3287       GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, &stored);
3288
3289   GST_OBJECT_LOCK (pad);
3290   return *data == GST_FLOW_OK;
3291 }
3292
3293 /* this is the chain function that does not perform the additional argument
3294  * checking for that little extra speed.
3295  */
3296 static inline GstFlowReturn
3297 gst_pad_chain_data_unchecked (GstPad * pad, GstPadProbeType type, void *data)
3298 {
3299   GstFlowReturn ret;
3300   GstObject *parent;
3301
3302   GST_PAD_STREAM_LOCK (pad);
3303
3304   GST_OBJECT_LOCK (pad);
3305   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
3306     goto flushing;
3307
3308   if (G_UNLIKELY (GST_PAD_MODE (pad) != GST_PAD_MODE_PUSH))
3309     goto wrong_mode;
3310
3311   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_BLOCK, data, probe_stopped);
3312
3313   PROBE_PUSH (pad, type, data, probe_stopped);
3314
3315   parent = GST_OBJECT_PARENT (pad);
3316   GST_OBJECT_UNLOCK (pad);
3317
3318   /* NOTE: we read the chainfunc unlocked.
3319    * we cannot hold the lock for the pad so we might send
3320    * the data to the wrong function. This is not really a
3321    * problem since functions are assigned at creation time
3322    * and don't change that often... */
3323   if (G_LIKELY (type & GST_PAD_PROBE_TYPE_BUFFER)) {
3324     GstPadChainFunction chainfunc;
3325
3326     if (G_UNLIKELY ((chainfunc = GST_PAD_CHAINFUNC (pad)) == NULL))
3327       goto no_function;
3328
3329     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3330         "calling chainfunction &%s with buffer %" GST_PTR_FORMAT,
3331         GST_DEBUG_FUNCPTR_NAME (chainfunc), GST_BUFFER (data));
3332
3333     ret = chainfunc (pad, parent, GST_BUFFER_CAST (data));
3334
3335     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3336         "called chainfunction &%s with buffer %p, returned %s",
3337         GST_DEBUG_FUNCPTR_NAME (chainfunc), data, gst_flow_get_name (ret));
3338   } else {
3339     GstPadChainListFunction chainlistfunc;
3340
3341     if (G_UNLIKELY ((chainlistfunc = GST_PAD_CHAINLISTFUNC (pad)) == NULL))
3342       goto no_function;
3343
3344     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3345         "calling chainlistfunction &%s",
3346         GST_DEBUG_FUNCPTR_NAME (chainlistfunc));
3347
3348     ret = chainlistfunc (pad, parent, GST_BUFFER_LIST_CAST (data));
3349
3350     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3351         "called chainlistfunction &%s, returned %s",
3352         GST_DEBUG_FUNCPTR_NAME (chainlistfunc), gst_flow_get_name (ret));
3353   }
3354
3355   GST_PAD_STREAM_UNLOCK (pad);
3356
3357   return ret;
3358
3359   /* ERRORS */
3360 flushing:
3361   {
3362     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3363         "chaining, but pad was flushing");
3364     GST_OBJECT_UNLOCK (pad);
3365     GST_PAD_STREAM_UNLOCK (pad);
3366     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3367     return GST_FLOW_WRONG_STATE;
3368   }
3369 wrong_mode:
3370   {
3371     GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
3372         ("chain on pad %s:%s but it was not in push mode",
3373             GST_DEBUG_PAD_NAME (pad)));
3374     GST_OBJECT_UNLOCK (pad);
3375     GST_PAD_STREAM_UNLOCK (pad);
3376     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3377     return GST_FLOW_ERROR;
3378   }
3379 probe_stopped:
3380   {
3381     GST_OBJECT_UNLOCK (pad);
3382     GST_PAD_STREAM_UNLOCK (pad);
3383     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3384
3385     switch (ret) {
3386       case GST_FLOW_CUSTOM_SUCCESS:
3387         GST_DEBUG_OBJECT (pad, "dropped buffer");
3388         ret = GST_FLOW_OK;
3389         break;
3390       default:
3391         GST_DEBUG_OBJECT (pad, "en error occured %s", gst_flow_get_name (ret));
3392         break;
3393     }
3394     return ret;
3395   }
3396 no_function:
3397   {
3398     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3399     GST_ELEMENT_ERROR (parent, CORE, PAD, (NULL),
3400         ("chain on pad %s:%s but it has no chainfunction",
3401             GST_DEBUG_PAD_NAME (pad)));
3402     GST_PAD_STREAM_UNLOCK (pad);
3403     return GST_FLOW_NOT_SUPPORTED;
3404   }
3405 }
3406
3407 /**
3408  * gst_pad_chain:
3409  * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not.
3410  * @buffer: (transfer full): the #GstBuffer to send, return GST_FLOW_ERROR
3411  *     if not.
3412  *
3413  * Chain a buffer to @pad.
3414  *
3415  * The function returns #GST_FLOW_WRONG_STATE if the pad was flushing.
3416  *
3417  * If the buffer type is not acceptable for @pad (as negotiated with a
3418  * preceeding GST_EVENT_CAPS event), this function returns
3419  * #GST_FLOW_NOT_NEGOTIATED.
3420  *
3421  * The function proceeds calling the chain function installed on @pad (see
3422  * gst_pad_set_chain_function()) and the return value of that function is
3423  * returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no
3424  * chain function.
3425  *
3426  * In all cases, success or failure, the caller loses its reference to @buffer
3427  * after calling this function.
3428  *
3429  * Returns: a #GstFlowReturn from the pad.
3430  *
3431  * MT safe.
3432  */
3433 GstFlowReturn
3434 gst_pad_chain (GstPad * pad, GstBuffer * buffer)
3435 {
3436   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
3437   g_return_val_if_fail (GST_PAD_IS_SINK (pad), GST_FLOW_ERROR);
3438   g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
3439
3440   return gst_pad_chain_data_unchecked (pad,
3441       GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH, buffer);
3442 }
3443
3444 static GstFlowReturn
3445 gst_pad_chain_list_default (GstPad * pad, GstObject * parent,
3446     GstBufferList * list)
3447 {
3448   guint i, len;
3449   GstBuffer *buffer;
3450   GstFlowReturn ret;
3451
3452   GST_INFO_OBJECT (pad, "chaining each group in list as a merged buffer");
3453
3454   len = gst_buffer_list_length (list);
3455
3456   ret = GST_FLOW_OK;
3457   for (i = 0; i < len; i++) {
3458     buffer = gst_buffer_list_get (list, i);
3459     ret =
3460         gst_pad_chain_data_unchecked (pad,
3461         GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH,
3462         gst_buffer_ref (buffer));
3463     if (ret != GST_FLOW_OK)
3464       break;
3465   }
3466   gst_buffer_list_unref (list);
3467
3468   return ret;
3469 }
3470
3471 /**
3472  * gst_pad_chain_list:
3473  * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not.
3474  * @list: (transfer full): the #GstBufferList to send, return GST_FLOW_ERROR
3475  *     if not.
3476  *
3477  * Chain a bufferlist to @pad.
3478  *
3479  * The function returns #GST_FLOW_WRONG_STATE if the pad was flushing.
3480  *
3481  * If @pad was not negotiated properly with a CAPS event, this function
3482  * returns #GST_FLOW_NOT_NEGOTIATED.
3483  *
3484  * The function proceeds calling the chainlist function installed on @pad (see
3485  * gst_pad_set_chain_list_function()) and the return value of that function is
3486  * returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no
3487  * chainlist function.
3488  *
3489  * In all cases, success or failure, the caller loses its reference to @list
3490  * after calling this function.
3491  *
3492  * MT safe.
3493  *
3494  * Returns: a #GstFlowReturn from the pad.
3495  *
3496  * Since: 0.10.24
3497  */
3498 GstFlowReturn
3499 gst_pad_chain_list (GstPad * pad, GstBufferList * list)
3500 {
3501   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
3502   g_return_val_if_fail (GST_PAD_IS_SINK (pad), GST_FLOW_ERROR);
3503   g_return_val_if_fail (GST_IS_BUFFER_LIST (list), GST_FLOW_ERROR);
3504
3505   return gst_pad_chain_data_unchecked (pad,
3506       GST_PAD_PROBE_TYPE_BUFFER_LIST | GST_PAD_PROBE_TYPE_PUSH, list);
3507 }
3508
3509 static GstFlowReturn
3510 gst_pad_push_data (GstPad * pad, GstPadProbeType type, void *data)
3511 {
3512   GstPad *peer;
3513   GstFlowReturn ret;
3514
3515   GST_OBJECT_LOCK (pad);
3516   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
3517     goto flushing;
3518
3519   if (G_UNLIKELY (GST_PAD_MODE (pad) != GST_PAD_MODE_PUSH))
3520     goto wrong_mode;
3521
3522   if (G_UNLIKELY (GST_PAD_HAS_PENDING_EVENTS (pad))) {
3523     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PENDING_EVENTS);
3524
3525     GST_DEBUG_OBJECT (pad, "pushing all sticky events");
3526
3527     ret = GST_FLOW_OK;
3528     events_foreach (pad, push_sticky, &ret);
3529     if (ret != GST_FLOW_OK)
3530       goto events_error;
3531   }
3532
3533   /* do block probes */
3534   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_BLOCK, data, probe_stopped);
3535
3536   /* do post-blocking probes */
3537   PROBE_PUSH (pad, type, data, probe_stopped);
3538
3539   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
3540     goto not_linked;
3541
3542   /* take ref to peer pad before releasing the lock */
3543   gst_object_ref (peer);
3544   pad->priv->using++;
3545   GST_OBJECT_UNLOCK (pad);
3546
3547   ret = gst_pad_chain_data_unchecked (peer, type, data);
3548
3549   gst_object_unref (peer);
3550
3551   GST_OBJECT_LOCK (pad);
3552   pad->priv->using--;
3553   if (pad->priv->using == 0) {
3554     /* pad is not active anymore, trigger idle callbacks */
3555     PROBE_NO_DATA (pad, GST_PAD_PROBE_TYPE_PUSH | GST_PAD_PROBE_TYPE_IDLE,
3556         probe_stopped, ret);
3557   }
3558   GST_OBJECT_UNLOCK (pad);
3559
3560   return ret;
3561
3562   /* ERROR recovery here */
3563   /* ERRORS */
3564 flushing:
3565   {
3566     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3567         "pushing, but pad was flushing");
3568     GST_OBJECT_UNLOCK (pad);
3569     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3570     return GST_FLOW_WRONG_STATE;
3571   }
3572 wrong_mode:
3573   {
3574     GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
3575         ("pushing on pad %s:%s but it was not activated in push mode",
3576             GST_DEBUG_PAD_NAME (pad)));
3577     GST_OBJECT_UNLOCK (pad);
3578     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3579     return GST_FLOW_ERROR;
3580   }
3581 events_error:
3582   {
3583     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3584         "error pushing events, return %s", gst_flow_get_name (ret));
3585     GST_OBJECT_UNLOCK (pad);
3586     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3587     return ret;
3588   }
3589 probe_stopped:
3590   {
3591     GST_OBJECT_UNLOCK (pad);
3592     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3593
3594     switch (ret) {
3595       case GST_FLOW_CUSTOM_SUCCESS:
3596         GST_DEBUG_OBJECT (pad, "dropped buffer");
3597         ret = GST_FLOW_OK;
3598         break;
3599       default:
3600         GST_DEBUG_OBJECT (pad, "en error occured %s", gst_flow_get_name (ret));
3601         break;
3602     }
3603     return ret;
3604   }
3605 not_linked:
3606   {
3607     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3608         "pushing, but it was not linked");
3609     GST_OBJECT_UNLOCK (pad);
3610     gst_mini_object_unref (GST_MINI_OBJECT_CAST (data));
3611     return GST_FLOW_NOT_LINKED;
3612   }
3613 }
3614
3615 /**
3616  * gst_pad_push:
3617  * @pad: a source #GstPad, returns #GST_FLOW_ERROR if not.
3618  * @buffer: (transfer full): the #GstBuffer to push returns GST_FLOW_ERROR
3619  *     if not.
3620  *
3621  * Pushes a buffer to the peer of @pad.
3622  *
3623  * This function will call installed block probes before triggering any
3624  * installed data probes.
3625  *
3626  * The function proceeds calling gst_pad_chain() on the peer pad and returns
3627  * the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will
3628  * be returned.
3629  *
3630  * In all cases, success or failure, the caller loses its reference to @buffer
3631  * after calling this function.
3632  *
3633  * Returns: a #GstFlowReturn from the peer pad.
3634  *
3635  * MT safe.
3636  */
3637 GstFlowReturn
3638 gst_pad_push (GstPad * pad, GstBuffer * buffer)
3639 {
3640   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
3641   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
3642   g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
3643
3644   return gst_pad_push_data (pad,
3645       GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH, buffer);
3646 }
3647
3648 /**
3649  * gst_pad_push_list:
3650  * @pad: a source #GstPad, returns #GST_FLOW_ERROR if not.
3651  * @list: (transfer full): the #GstBufferList to push returns GST_FLOW_ERROR
3652  *     if not.
3653  *
3654  * Pushes a buffer list to the peer of @pad.
3655  *
3656  * This function will call installed block probes before triggering any
3657  * installed data probes.
3658  *
3659  * The function proceeds calling the chain function on the peer pad and returns
3660  * the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will
3661  * be returned. If the peer pad does not have any installed chainlist function
3662  * every group buffer of the list will be merged into a normal #GstBuffer and
3663  * chained via gst_pad_chain().
3664  *
3665  * In all cases, success or failure, the caller loses its reference to @list
3666  * after calling this function.
3667  *
3668  * Returns: a #GstFlowReturn from the peer pad.
3669  *
3670  * MT safe.
3671  *
3672  * Since: 0.10.24
3673  */
3674 GstFlowReturn
3675 gst_pad_push_list (GstPad * pad, GstBufferList * list)
3676 {
3677   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
3678   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
3679   g_return_val_if_fail (GST_IS_BUFFER_LIST (list), GST_FLOW_ERROR);
3680
3681   return gst_pad_push_data (pad,
3682       GST_PAD_PROBE_TYPE_BUFFER_LIST | GST_PAD_PROBE_TYPE_PUSH, list);
3683 }
3684
3685 static GstFlowReturn
3686 gst_pad_get_range_unchecked (GstPad * pad, guint64 offset, guint size,
3687     GstBuffer ** buffer)
3688 {
3689   GstFlowReturn ret;
3690   GstPadGetRangeFunction getrangefunc;
3691   GstObject *parent;
3692
3693   GST_PAD_STREAM_LOCK (pad);
3694
3695   GST_OBJECT_LOCK (pad);
3696   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
3697     goto flushing;
3698
3699   if (G_UNLIKELY (GST_PAD_MODE (pad) != GST_PAD_MODE_PULL))
3700     goto wrong_mode;
3701
3702   if (G_UNLIKELY (GST_PAD_HAS_PENDING_EVENTS (pad))) {
3703     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PENDING_EVENTS);
3704
3705     GST_DEBUG_OBJECT (pad, "pushing all sticky events");
3706
3707     ret = GST_FLOW_OK;
3708     events_foreach (pad, push_sticky, &ret);
3709     if (ret != GST_FLOW_OK)
3710       goto events_error;
3711   }
3712
3713   /* when one of the probes returns a buffer, probed_data will be called and we
3714    * skip calling the getrange function */
3715   PROBE_PRE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BLOCK,
3716       *buffer, offset, size, probe_stopped, probed_data, GST_FLOW_OK);
3717
3718   ACQUIRE_PARENT (pad, parent, no_parent);
3719   GST_OBJECT_UNLOCK (pad);
3720
3721   if (G_UNLIKELY ((getrangefunc = GST_PAD_GETRANGEFUNC (pad)) == NULL))
3722     goto no_function;
3723
3724   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3725       "calling getrangefunc %s, offset %"
3726       G_GUINT64_FORMAT ", size %u",
3727       GST_DEBUG_FUNCPTR_NAME (getrangefunc), offset, size);
3728
3729   ret = getrangefunc (pad, parent, offset, size, buffer);
3730
3731   RELEASE_PARENT (parent);
3732
3733   if (G_UNLIKELY (ret != GST_FLOW_OK))
3734     goto get_range_failed;
3735
3736   /* can only fire the signal if we have a valid buffer */
3737   GST_OBJECT_LOCK (pad);
3738 probed_data:
3739   PROBE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BUFFER,
3740       *buffer, offset, size, probe_stopped_unref);
3741   GST_OBJECT_UNLOCK (pad);
3742
3743   GST_PAD_STREAM_UNLOCK (pad);
3744
3745   return ret;
3746
3747   /* ERRORS */
3748 flushing:
3749   {
3750     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3751         "getrange, but pad was flushing");
3752     GST_OBJECT_UNLOCK (pad);
3753     GST_PAD_STREAM_UNLOCK (pad);
3754     return GST_FLOW_WRONG_STATE;
3755   }
3756 wrong_mode:
3757   {
3758     GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
3759         ("getrange on pad %s:%s but it was not activated in pull mode",
3760             GST_DEBUG_PAD_NAME (pad)));
3761     GST_OBJECT_UNLOCK (pad);
3762     GST_PAD_STREAM_UNLOCK (pad);
3763     return GST_FLOW_ERROR;
3764   }
3765 events_error:
3766   {
3767     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "error pushing events");
3768     GST_OBJECT_UNLOCK (pad);
3769     GST_PAD_STREAM_UNLOCK (pad);
3770     return ret;
3771   }
3772 no_parent:
3773   {
3774     GST_DEBUG_OBJECT (pad, "no parent");
3775     GST_OBJECT_UNLOCK (pad);
3776     GST_PAD_STREAM_UNLOCK (pad);
3777     return GST_FLOW_WRONG_STATE;
3778   }
3779 no_function:
3780   {
3781     GST_ELEMENT_ERROR (parent, CORE, PAD, (NULL),
3782         ("getrange on pad %s:%s but it has no getrangefunction",
3783             GST_DEBUG_PAD_NAME (pad)));
3784     RELEASE_PARENT (parent);
3785     GST_PAD_STREAM_UNLOCK (pad);
3786     return GST_FLOW_NOT_SUPPORTED;
3787   }
3788 probe_stopped:
3789   {
3790     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3791         "probe returned %s", gst_flow_get_name (ret));
3792     GST_OBJECT_UNLOCK (pad);
3793     GST_PAD_STREAM_UNLOCK (pad);
3794     return ret;
3795   }
3796 probe_stopped_unref:
3797   {
3798     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3799         "probe returned %s", gst_flow_get_name (ret));
3800     GST_OBJECT_UNLOCK (pad);
3801     GST_PAD_STREAM_UNLOCK (pad);
3802     gst_buffer_unref (*buffer);
3803     *buffer = NULL;
3804     return ret;
3805   }
3806 get_range_failed:
3807   {
3808     GST_PAD_STREAM_UNLOCK (pad);
3809     *buffer = NULL;
3810     GST_CAT_LEVEL_LOG (GST_CAT_SCHEDULING,
3811         (ret >= GST_FLOW_EOS) ? GST_LEVEL_INFO : GST_LEVEL_WARNING,
3812         pad, "getrange failed, flow: %s", gst_flow_get_name (ret));
3813     return ret;
3814   }
3815 }
3816
3817 /**
3818  * gst_pad_get_range:
3819  * @pad: a src #GstPad, returns #GST_FLOW_ERROR if not.
3820  * @offset: The start offset of the buffer
3821  * @size: The length of the buffer
3822  * @buffer: (out callee-allocates): a pointer to hold the #GstBuffer,
3823  *     returns #GST_FLOW_ERROR if %NULL.
3824  *
3825  * When @pad is flushing this function returns #GST_FLOW_WRONG_STATE
3826  * immediately and @buffer is %NULL.
3827  *
3828  * Calls the getrange function of @pad, see #GstPadGetRangeFunction for a
3829  * description of a getrange function. If @pad has no getrange function
3830  * installed (see gst_pad_set_getrange_function()) this function returns
3831  * #GST_FLOW_NOT_SUPPORTED.
3832  *
3833  * This is a lowlevel function. Usualy gst_pad_pull_range() is used.
3834  *
3835  * Returns: a #GstFlowReturn from the pad.
3836  *
3837  * MT safe.
3838  */
3839 GstFlowReturn
3840 gst_pad_get_range (GstPad * pad, guint64 offset, guint size,
3841     GstBuffer ** buffer)
3842 {
3843   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
3844   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
3845   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
3846
3847   return gst_pad_get_range_unchecked (pad, offset, size, buffer);
3848 }
3849
3850 /**
3851  * gst_pad_pull_range:
3852  * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not.
3853  * @offset: The start offset of the buffer
3854  * @size: The length of the buffer
3855  * @buffer: (out callee-allocates): a pointer to hold the #GstBuffer, returns
3856  *     GST_FLOW_ERROR if %NULL.
3857  *
3858  * Pulls a @buffer from the peer pad.
3859  *
3860  * This function will first trigger the pad block signal if it was
3861  * installed.
3862  *
3863  * When @pad is not linked #GST_FLOW_NOT_LINKED is returned else this
3864  * function returns the result of gst_pad_get_range() on the peer pad.
3865  * See gst_pad_get_range() for a list of return values and for the
3866  * semantics of the arguments of this function.
3867  *
3868  * Returns: a #GstFlowReturn from the peer pad.
3869  * When this function returns #GST_FLOW_OK, @buffer will contain a valid
3870  * #GstBuffer that should be freed with gst_buffer_unref() after usage.
3871  * @buffer may not be used or freed when any other return value than
3872  * #GST_FLOW_OK is returned.
3873  *
3874  * MT safe.
3875  */
3876 GstFlowReturn
3877 gst_pad_pull_range (GstPad * pad, guint64 offset, guint size,
3878     GstBuffer ** buffer)
3879 {
3880   GstPad *peer;
3881   GstFlowReturn ret;
3882
3883   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
3884   g_return_val_if_fail (GST_PAD_IS_SINK (pad), GST_FLOW_ERROR);
3885   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
3886
3887   GST_OBJECT_LOCK (pad);
3888   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
3889     goto flushing;
3890
3891   if (G_UNLIKELY (GST_PAD_MODE (pad) != GST_PAD_MODE_PULL))
3892     goto wrong_mode;
3893
3894   /* when one of the probes returns a buffer, probed_data will be called and we
3895    * skip calling the peer getrange function */
3896   PROBE_PRE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BLOCK,
3897       *buffer, offset, size, pre_probe_stopped, probed_data, GST_FLOW_OK);
3898
3899   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
3900     goto not_linked;
3901
3902   gst_object_ref (peer);
3903   pad->priv->using++;
3904   GST_OBJECT_UNLOCK (pad);
3905
3906   ret = gst_pad_get_range_unchecked (peer, offset, size, buffer);
3907
3908   gst_object_unref (peer);
3909
3910   GST_OBJECT_LOCK (pad);
3911   pad->priv->using--;
3912   if (pad->priv->using == 0) {
3913     /* pad is not active anymore, trigger idle callbacks */
3914     PROBE_NO_DATA (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_IDLE,
3915         post_probe_stopped, ret);
3916   }
3917
3918   if (G_UNLIKELY (ret != GST_FLOW_OK))
3919     goto pull_range_failed;
3920
3921 probed_data:
3922   PROBE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BUFFER,
3923       *buffer, offset, size, post_probe_stopped);
3924
3925   GST_OBJECT_UNLOCK (pad);
3926
3927   return ret;
3928
3929   /* ERROR recovery here */
3930 flushing:
3931   {
3932     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3933         "pullrange, but pad was flushing");
3934     GST_OBJECT_UNLOCK (pad);
3935     return GST_FLOW_WRONG_STATE;
3936   }
3937 wrong_mode:
3938   {
3939     GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
3940         ("gpulltange on pad %s:%s but it was not activated in pull mode",
3941             GST_DEBUG_PAD_NAME (pad)));
3942     GST_OBJECT_UNLOCK (pad);
3943     return GST_FLOW_ERROR;
3944   }
3945 pre_probe_stopped:
3946   {
3947     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "pre probe returned %s",
3948         gst_flow_get_name (ret));
3949     GST_OBJECT_UNLOCK (pad);
3950     return ret;
3951   }
3952 not_linked:
3953   {
3954     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3955         "pulling range, but it was not linked");
3956     GST_OBJECT_UNLOCK (pad);
3957     return GST_FLOW_NOT_LINKED;
3958   }
3959 pull_range_failed:
3960   {
3961     *buffer = NULL;
3962     GST_OBJECT_UNLOCK (pad);
3963     GST_CAT_LEVEL_LOG (GST_CAT_SCHEDULING,
3964         (ret >= GST_FLOW_EOS) ? GST_LEVEL_INFO : GST_LEVEL_WARNING,
3965         pad, "pullrange failed, flow: %s", gst_flow_get_name (ret));
3966     return ret;
3967   }
3968 post_probe_stopped:
3969   {
3970     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
3971         "post probe returned %s", gst_flow_get_name (ret));
3972     GST_OBJECT_UNLOCK (pad);
3973     if (ret == GST_FLOW_OK)
3974       gst_buffer_unref (*buffer);
3975     *buffer = NULL;
3976     return ret;
3977   }
3978 }
3979
3980 static gboolean
3981 gst_pad_store_sticky_event (GstPad * pad, GstEvent * event, gboolean locked)
3982 {
3983   guint i, len;
3984   GstEventType type;
3985   GArray *events;
3986   gboolean res = FALSE;
3987   const gchar *name = NULL;
3988
3989   type = GST_EVENT_TYPE (event);
3990   if (type & GST_EVENT_TYPE_STICKY_MULTI)
3991     name = gst_structure_get_name (gst_event_get_structure (event));
3992
3993   events = pad->priv->events;
3994   len = events->len;
3995
3996   for (i = 0; i < len; i++) {
3997     PadEvent *ev = &g_array_index (events, PadEvent, i);
3998
3999     if (ev->event == NULL)
4000       continue;
4001
4002     if (type == GST_EVENT_TYPE (ev->event)) {
4003       /* matching types, check matching name if needed */
4004       if (name && !gst_event_has_name (ev->event, name))
4005         continue;
4006
4007       /* overwrite */
4008       if ((res = gst_event_replace (&ev->event, event)))
4009         ev->received = FALSE;
4010       break;
4011     }
4012   }
4013   if (i == len) {
4014     PadEvent ev;
4015     ev.event = gst_event_ref (event);
4016     ev.received = FALSE;
4017     g_array_append_val (events, ev);
4018     res = TRUE;
4019   }
4020
4021   if (res) {
4022     pad->priv->events_cookie++;
4023     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
4024
4025     GST_LOG_OBJECT (pad, "stored sticky event %s", GST_EVENT_TYPE_NAME (event));
4026
4027     switch (GST_EVENT_TYPE (event)) {
4028       case GST_EVENT_CAPS:
4029         if (locked)
4030           GST_OBJECT_UNLOCK (pad);
4031
4032         GST_DEBUG_OBJECT (pad, "notify caps");
4033         g_object_notify_by_pspec ((GObject *) pad, pspec_caps);
4034
4035         if (locked)
4036           GST_OBJECT_LOCK (pad);
4037         break;
4038       default:
4039         break;
4040     }
4041   }
4042   return res;
4043 }
4044
4045 static GstFlowReturn
4046 gst_pad_push_event_unchecked (GstPad * pad, GstEvent * event,
4047     GstPadProbeType type, gboolean * stored)
4048 {
4049   GstFlowReturn ret;
4050   GstPad *peerpad;
4051   GstEventType event_type;
4052   gboolean sticky;
4053
4054   sticky = GST_EVENT_IS_STICKY (event);
4055
4056   GST_OBJECT_LOCK (pad);
4057
4058   /* Two checks to be made:
4059    * . (un)set the FLUSHING flag for flushing events,
4060    * . handle pad blocking */
4061   event_type = GST_EVENT_TYPE (event);
4062   *stored = FALSE;
4063   switch (event_type) {
4064     case GST_EVENT_FLUSH_START:
4065       GST_PAD_SET_FLUSHING (pad);
4066
4067       GST_PAD_BLOCK_BROADCAST (pad);
4068       type |= GST_PAD_PROBE_TYPE_EVENT_FLUSH;
4069       break;
4070     case GST_EVENT_FLUSH_STOP:
4071       GST_PAD_UNSET_FLUSHING (pad);
4072
4073       /* Remove sticky EOS events */
4074       GST_LOG_OBJECT (pad, "Removing pending EOS events");
4075       remove_event_by_type (pad, GST_EVENT_EOS);
4076
4077       type |= GST_PAD_PROBE_TYPE_EVENT_FLUSH;
4078       break;
4079     default:
4080     {
4081       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4082         goto flushed;
4083
4084       /* store the event on the pad, but only on srcpads. We always store the
4085        * event exactly how it was sent */
4086       if (sticky) {
4087         /* srcpad sticky events are store immediately, the received flag is set
4088          * to FALSE and will be set to TRUE when we can successfully push the
4089          * event to the peer pad */
4090         if (gst_pad_store_sticky_event (pad, event, TRUE)) {
4091           GST_DEBUG_OBJECT (pad, "event %s updated",
4092               GST_EVENT_TYPE_NAME (event));
4093         }
4094         *stored = TRUE;
4095       }
4096
4097       switch (GST_EVENT_TYPE (event)) {
4098         case GST_EVENT_SEGMENT:
4099           /* pass the adjusted segment event on. We need to do this even if
4100            * there is no peer pad because of the probes. */
4101           event = apply_pad_offset (pad, event);
4102           break;
4103         case GST_EVENT_RECONFIGURE:
4104           if (GST_PAD_IS_SINK (pad))
4105             GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
4106           break;
4107         default:
4108           break;
4109       }
4110       PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH |
4111           GST_PAD_PROBE_TYPE_BLOCK, event, probe_stopped);
4112       break;
4113     }
4114   }
4115
4116   /* send probes after modifying the events above */
4117   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH, event, probe_stopped);
4118
4119   /* now check the peer pad */
4120   peerpad = GST_PAD_PEER (pad);
4121   if (peerpad == NULL)
4122     goto not_linked;
4123
4124   gst_object_ref (peerpad);
4125   pad->priv->using++;
4126   GST_OBJECT_UNLOCK (pad);
4127
4128   GST_LOG_OBJECT (pad, "sending event %p (%s) to peerpad %" GST_PTR_FORMAT,
4129       event, GST_EVENT_TYPE_NAME (event), peerpad);
4130
4131   ret = gst_pad_send_event_unchecked (peerpad, event, type);
4132
4133   /* Note: we gave away ownership of the event at this point but we can still
4134    * print the old pointer */
4135   GST_LOG_OBJECT (pad,
4136       "sent event %p to peerpad %" GST_PTR_FORMAT ", ret %s", event, peerpad,
4137       gst_flow_get_name (ret));
4138
4139   gst_object_unref (peerpad);
4140
4141   GST_OBJECT_LOCK (pad);
4142   if (sticky) {
4143     if (ret == GST_FLOW_OK) {
4144       PadEvent *ev;
4145
4146       if ((ev = find_event (pad, event)))
4147         ev->received = TRUE;
4148
4149       GST_DEBUG_OBJECT (pad, "event marked received");
4150     } else {
4151       GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
4152       GST_DEBUG_OBJECT (pad, "mark pending events");
4153     }
4154   }
4155   pad->priv->using--;
4156   if (pad->priv->using == 0) {
4157     /* pad is not active anymore, trigger idle callbacks */
4158     PROBE_NO_DATA (pad, GST_PAD_PROBE_TYPE_PUSH | GST_PAD_PROBE_TYPE_IDLE,
4159         idle_probe_stopped, ret);
4160   }
4161   GST_OBJECT_UNLOCK (pad);
4162
4163   return ret;
4164
4165   /* ERROR handling */
4166 flushed:
4167   {
4168     GST_DEBUG_OBJECT (pad, "We're flushing");
4169     GST_OBJECT_UNLOCK (pad);
4170     gst_event_unref (event);
4171     return GST_FLOW_WRONG_STATE;
4172   }
4173 probe_stopped:
4174   {
4175     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
4176     GST_OBJECT_UNLOCK (pad);
4177     gst_event_unref (event);
4178
4179     switch (ret) {
4180       case GST_FLOW_CUSTOM_SUCCESS:
4181         GST_DEBUG_OBJECT (pad, "dropped event");
4182         ret = GST_FLOW_OK;
4183         break;
4184       default:
4185         GST_DEBUG_OBJECT (pad, "en error occured %s", gst_flow_get_name (ret));
4186         break;
4187     }
4188     return ret;
4189   }
4190 not_linked:
4191   {
4192     GST_DEBUG_OBJECT (pad, "Dropping event because pad is not linked");
4193     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
4194     GST_OBJECT_UNLOCK (pad);
4195     gst_event_unref (event);
4196     return sticky ? GST_FLOW_OK : GST_FLOW_NOT_LINKED;
4197   }
4198 idle_probe_stopped:
4199   {
4200     GST_DEBUG_OBJECT (pad, "Idle probe returned %s", gst_flow_get_name (ret));
4201     GST_OBJECT_UNLOCK (pad);
4202     return ret;
4203   }
4204 }
4205
4206 /**
4207  * gst_pad_push_event:
4208  * @pad: a #GstPad to push the event to.
4209  * @event: (transfer full): the #GstEvent to send to the pad.
4210  *
4211  * Sends the event to the peer of the given pad. This function is
4212  * mainly used by elements to send events to their peer
4213  * elements.
4214  *
4215  * This function takes owership of the provided event so you should
4216  * gst_event_ref() it if you want to reuse the event after this call.
4217  *
4218  * Returns: TRUE if the event was handled.
4219  *
4220  * MT safe.
4221  */
4222 gboolean
4223 gst_pad_push_event (GstPad * pad, GstEvent * event)
4224 {
4225   gboolean res;
4226   GstPadProbeType type;
4227   gboolean stored;
4228
4229   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
4230   g_return_val_if_fail (event != NULL, FALSE);
4231   g_return_val_if_fail (GST_IS_EVENT (event), FALSE);
4232
4233   if (GST_PAD_IS_SRC (pad)) {
4234     if (G_UNLIKELY (!GST_EVENT_IS_DOWNSTREAM (event)))
4235       goto wrong_direction;
4236     type = GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM;
4237   } else if (GST_PAD_IS_SINK (pad)) {
4238     if (G_UNLIKELY (!GST_EVENT_IS_UPSTREAM (event)))
4239       goto wrong_direction;
4240     /* events pushed on sinkpad never are sticky */
4241     type = GST_PAD_PROBE_TYPE_EVENT_UPSTREAM;
4242   } else
4243     goto unknown_direction;
4244
4245   if (gst_pad_push_event_unchecked (pad, event, type, &stored) != GST_FLOW_OK)
4246     res = stored ? TRUE : FALSE;
4247   else
4248     res = TRUE;
4249
4250   return res;
4251
4252   /* ERROR handling */
4253 wrong_direction:
4254   {
4255     g_warning ("pad %s:%s pushing %s event in wrong direction",
4256         GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE_NAME (event));
4257     gst_event_unref (event);
4258     return FALSE;
4259   }
4260 unknown_direction:
4261   {
4262     g_warning ("pad %s:%s has invalid direction", GST_DEBUG_PAD_NAME (pad));
4263     gst_event_unref (event);
4264     return FALSE;
4265   }
4266 }
4267
4268 /* Check if we can call the event function with the given event */
4269 static GstFlowReturn
4270 pre_eventfunc_check (GstPad * pad, GstEvent * event)
4271 {
4272   GstCaps *caps, *templ;
4273
4274   switch (GST_EVENT_TYPE (event)) {
4275     case GST_EVENT_CAPS:
4276     {
4277       /* backwards compatibility mode for caps */
4278       gst_event_parse_caps (event, &caps);
4279
4280       /* See if pad accepts the caps */
4281       templ = gst_pad_get_pad_template_caps (pad);
4282       if (!gst_caps_is_subset (caps, templ))
4283         goto not_accepted;
4284
4285       gst_caps_unref (templ);
4286       break;
4287     }
4288     default:
4289       break;
4290   }
4291   return GST_FLOW_OK;
4292
4293   /* ERRORS */
4294 not_accepted:
4295   {
4296     gst_caps_unref (templ);
4297     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
4298         "caps %" GST_PTR_FORMAT " not accepted", caps);
4299     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
4300         "no intersection with template %" GST_PTR_FORMAT, templ);
4301     return GST_FLOW_NOT_NEGOTIATED;
4302   }
4303 }
4304
4305 static GstFlowReturn
4306 gst_pad_send_event_unchecked (GstPad * pad, GstEvent * event,
4307     GstPadProbeType type)
4308 {
4309   GstFlowReturn ret;
4310   GstEventType event_type;
4311   gboolean serialized, need_unlock = FALSE, sticky;
4312   GstPadEventFunction eventfunc;
4313   GstObject *parent;
4314
4315   GST_OBJECT_LOCK (pad);
4316   if (GST_PAD_IS_SINK (pad))
4317     serialized = GST_EVENT_IS_SERIALIZED (event);
4318   else
4319     serialized = FALSE;
4320   sticky = GST_EVENT_IS_STICKY (event);
4321   event_type = GST_EVENT_TYPE (event);
4322   switch (event_type) {
4323     case GST_EVENT_FLUSH_START:
4324       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad,
4325           "have event type %d (FLUSH_START)", GST_EVENT_TYPE (event));
4326
4327       /* can't even accept a flush begin event when flushing */
4328       if (GST_PAD_IS_FLUSHING (pad))
4329         goto flushing;
4330
4331       GST_PAD_SET_FLUSHING (pad);
4332       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad, "set flush flag");
4333       break;
4334     case GST_EVENT_FLUSH_STOP:
4335       if (G_LIKELY (GST_PAD_MODE (pad) != GST_PAD_MODE_NONE)) {
4336         GST_PAD_UNSET_FLUSHING (pad);
4337         GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad, "cleared flush flag");
4338       }
4339       /* Remove pending EOS events */
4340       GST_LOG_OBJECT (pad, "Removing pending EOS events");
4341       remove_event_by_type (pad, GST_EVENT_EOS);
4342
4343       GST_OBJECT_UNLOCK (pad);
4344       /* grab stream lock */
4345       GST_PAD_STREAM_LOCK (pad);
4346       need_unlock = TRUE;
4347       GST_OBJECT_LOCK (pad);
4348       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4349         goto flushing;
4350       break;
4351     case GST_EVENT_RECONFIGURE:
4352       if (GST_PAD_IS_SRC (pad))
4353         GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
4354     default:
4355       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad,
4356           "have event type %" GST_PTR_FORMAT, event);
4357
4358       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4359         goto flushing;
4360
4361       if (serialized) {
4362         /* lock order: STREAM_LOCK, LOCK, recheck flushing. */
4363         GST_OBJECT_UNLOCK (pad);
4364         GST_PAD_STREAM_LOCK (pad);
4365         need_unlock = TRUE;
4366         GST_OBJECT_LOCK (pad);
4367         if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4368           goto flushing;
4369       }
4370
4371       switch (GST_EVENT_TYPE (event)) {
4372         case GST_EVENT_SEGMENT:
4373           event = apply_pad_offset (pad, event);
4374           break;
4375         default:
4376           break;
4377       }
4378
4379       /* now do the probe */
4380       PROBE_PUSH (pad,
4381           type | GST_PAD_PROBE_TYPE_PUSH |
4382           GST_PAD_PROBE_TYPE_BLOCK, event, probe_stopped);
4383
4384       PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH, event, probe_stopped);
4385       break;
4386   }
4387
4388   if (G_UNLIKELY ((eventfunc = GST_PAD_EVENTFUNC (pad)) == NULL))
4389     goto no_function;
4390
4391   ACQUIRE_PARENT (pad, parent, no_parent);
4392   GST_OBJECT_UNLOCK (pad);
4393
4394   ret = pre_eventfunc_check (pad, event);
4395   if (G_UNLIKELY (ret != GST_FLOW_OK))
4396     goto precheck_failed;
4397
4398   if (sticky)
4399     gst_event_ref (event);
4400
4401   if (eventfunc (pad, parent, event)) {
4402     ret = GST_FLOW_OK;
4403   } else {
4404     /* something went wrong */
4405     switch (event_type) {
4406       case GST_EVENT_CAPS:
4407         ret = GST_FLOW_NOT_NEGOTIATED;
4408         break;
4409       default:
4410         ret = GST_FLOW_ERROR;
4411         break;
4412     }
4413   }
4414   RELEASE_PARENT (parent);
4415
4416   GST_DEBUG_OBJECT (pad, "sent event, ret %s", gst_flow_get_name (ret));
4417
4418   if (sticky) {
4419     if (ret == GST_FLOW_OK) {
4420       /* after the event function accepted the event, we can store the sticky
4421        * event on the pad */
4422       gst_pad_store_sticky_event (pad, event, FALSE);
4423     }
4424     gst_event_unref (event);
4425   }
4426
4427   if (need_unlock)
4428     GST_PAD_STREAM_UNLOCK (pad);
4429
4430   return ret;
4431
4432   /* ERROR handling */
4433 flushing:
4434   {
4435     GST_OBJECT_UNLOCK (pad);
4436     if (need_unlock)
4437       GST_PAD_STREAM_UNLOCK (pad);
4438     GST_CAT_INFO_OBJECT (GST_CAT_EVENT, pad,
4439         "Received event on flushing pad. Discarding");
4440     gst_event_unref (event);
4441     return GST_FLOW_WRONG_STATE;
4442   }
4443 probe_stopped:
4444   {
4445     GST_OBJECT_UNLOCK (pad);
4446     if (need_unlock)
4447       GST_PAD_STREAM_UNLOCK (pad);
4448     gst_event_unref (event);
4449
4450     switch (ret) {
4451       case GST_FLOW_CUSTOM_SUCCESS:
4452         GST_DEBUG_OBJECT (pad, "dropped event");
4453         ret = GST_FLOW_OK;
4454         break;
4455       default:
4456         GST_DEBUG_OBJECT (pad, "en error occured %s", gst_flow_get_name (ret));
4457         break;
4458     }
4459     return ret;
4460   }
4461 no_function:
4462   {
4463     g_warning ("pad %s:%s has no event handler, file a bug.",
4464         GST_DEBUG_PAD_NAME (pad));
4465     GST_OBJECT_UNLOCK (pad);
4466     if (need_unlock)
4467       GST_PAD_STREAM_UNLOCK (pad);
4468     gst_event_unref (event);
4469     return GST_FLOW_NOT_SUPPORTED;
4470   }
4471 no_parent:
4472   {
4473     GST_DEBUG_OBJECT (pad, "no parent");
4474     GST_OBJECT_UNLOCK (pad);
4475     if (need_unlock)
4476       GST_PAD_STREAM_UNLOCK (pad);
4477     gst_event_unref (event);
4478     return GST_FLOW_WRONG_STATE;
4479   }
4480 precheck_failed:
4481   {
4482     GST_DEBUG_OBJECT (pad, "pre event check failed");
4483     RELEASE_PARENT (parent);
4484     if (need_unlock)
4485       GST_PAD_STREAM_UNLOCK (pad);
4486     gst_event_unref (event);
4487     return ret;
4488   }
4489 }
4490
4491 /**
4492  * gst_pad_send_event:
4493  * @pad: a #GstPad to send the event to.
4494  * @event: (transfer full): the #GstEvent to send to the pad.
4495  *
4496  * Sends the event to the pad. This function can be used
4497  * by applications to send events in the pipeline.
4498  *
4499  * If @pad is a source pad, @event should be an upstream event. If @pad is a
4500  * sink pad, @event should be a downstream event. For example, you would not
4501  * send a #GST_EVENT_EOS on a src pad; EOS events only propagate downstream.
4502  * Furthermore, some downstream events have to be serialized with data flow,
4503  * like EOS, while some can travel out-of-band, like #GST_EVENT_FLUSH_START. If
4504  * the event needs to be serialized with data flow, this function will take the
4505  * pad's stream lock while calling its event function.
4506  *
4507  * To find out whether an event type is upstream, downstream, or downstream and
4508  * serialized, see #GstEventTypeFlags, gst_event_type_get_flags(),
4509  * #GST_EVENT_IS_UPSTREAM, #GST_EVENT_IS_DOWNSTREAM, and
4510  * #GST_EVENT_IS_SERIALIZED. Note that in practice that an application or
4511  * plugin doesn't need to bother itself with this information; the core handles
4512  * all necessary locks and checks.
4513  *
4514  * This function takes owership of the provided event so you should
4515  * gst_event_ref() it if you want to reuse the event after this call.
4516  *
4517  * Returns: TRUE if the event was handled.
4518  */
4519 gboolean
4520 gst_pad_send_event (GstPad * pad, GstEvent * event)
4521 {
4522   gboolean result;
4523   GstPadProbeType type;
4524
4525   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
4526   g_return_val_if_fail (event != NULL, FALSE);
4527
4528   if (GST_PAD_IS_SINK (pad)) {
4529     if (G_UNLIKELY (!GST_EVENT_IS_DOWNSTREAM (event)))
4530       goto wrong_direction;
4531     type = GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM;
4532   } else if (GST_PAD_IS_SRC (pad)) {
4533     if (G_UNLIKELY (!GST_EVENT_IS_UPSTREAM (event)))
4534       goto wrong_direction;
4535     type = GST_PAD_PROBE_TYPE_EVENT_UPSTREAM;
4536   } else
4537     goto unknown_direction;
4538
4539   if (gst_pad_send_event_unchecked (pad, event, type) != GST_FLOW_OK)
4540     result = FALSE;
4541   else
4542     result = TRUE;
4543
4544   return result;
4545
4546   /* ERROR handling */
4547 wrong_direction:
4548   {
4549     g_warning ("pad %s:%s sending %s event in wrong direction",
4550         GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE_NAME (event));
4551     gst_event_unref (event);
4552     return FALSE;
4553   }
4554 unknown_direction:
4555   {
4556     g_warning ("pad %s:%s has invalid direction", GST_DEBUG_PAD_NAME (pad));
4557     gst_event_unref (event);
4558     return FALSE;
4559   }
4560 }
4561
4562 /**
4563  * gst_pad_set_element_private:
4564  * @pad: the #GstPad to set the private data of.
4565  * @priv: The private data to attach to the pad.
4566  *
4567  * Set the given private data gpointer on the pad.
4568  * This function can only be used by the element that owns the pad.
4569  * No locking is performed in this function.
4570  */
4571 void
4572 gst_pad_set_element_private (GstPad * pad, gpointer priv)
4573 {
4574   pad->element_private = priv;
4575 }
4576
4577 /**
4578  * gst_pad_get_element_private:
4579  * @pad: the #GstPad to get the private data of.
4580  *
4581  * Gets the private data of a pad.
4582  * No locking is performed in this function.
4583  *
4584  * Returns: (transfer none): a #gpointer to the private data.
4585  */
4586 gpointer
4587 gst_pad_get_element_private (GstPad * pad)
4588 {
4589   return pad->element_private;
4590 }
4591
4592 /**
4593  * gst_pad_get_sticky_event:
4594  * @pad: the #GstPad to get the event from.
4595  * @event_type: the #GstEventType that should be retrieved.
4596  * @idx: the index of the event
4597  *
4598  * Returns a new reference of the sticky event of type @event_type
4599  * from the event.
4600  *
4601  * Returns: (transfer full): a #GstEvent of type @event_type or NULL when no
4602  * event of @event_type was on @pad. Unref after usage.
4603  */
4604 GstEvent *
4605 gst_pad_get_sticky_event (GstPad * pad, GstEventType event_type, guint idx)
4606 {
4607   GstEvent *event = NULL;
4608   PadEvent *ev;
4609
4610   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
4611   g_return_val_if_fail ((event_type & GST_EVENT_TYPE_STICKY) != 0, NULL);
4612
4613   GST_OBJECT_LOCK (pad);
4614   ev = find_event_by_type (pad, event_type, idx);
4615   if (ev && (event = ev->event))
4616     gst_event_ref (event);
4617   GST_OBJECT_UNLOCK (pad);
4618
4619   return event;
4620 }
4621
4622 typedef struct
4623 {
4624   GstPadStickyEventsForeachFunction func;
4625   gpointer user_data;
4626 } ForeachDispatch;
4627
4628 static gboolean
4629 foreach_dispatch_function (GstPad * pad, PadEvent * ev, gpointer user_data)
4630 {
4631   ForeachDispatch *data = user_data;
4632   gboolean ret;
4633
4634   GST_OBJECT_UNLOCK (pad);
4635
4636   ret = data->func (pad, &ev->event, data->user_data);
4637
4638   GST_OBJECT_LOCK (pad);
4639
4640   return ret;
4641 }
4642
4643 /**
4644  * gst_pad_sticky_events_foreach:
4645  * @pad: the #GstPad that should be used for iteration.
4646  * @foreach_func: (scope call): the #GstPadStickyEventsForeachFunction that
4647  *                should be called for every event.
4648  * @user_data: (closure): the optional user data.
4649  *
4650  * Iterates all sticky events on @pad and calls @foreach_func for every
4651  * event. If @foreach_func returns %FALSE the iteration is immediately stopped.
4652  */
4653 void
4654 gst_pad_sticky_events_foreach (GstPad * pad,
4655     GstPadStickyEventsForeachFunction foreach_func, gpointer user_data)
4656 {
4657   ForeachDispatch data;
4658
4659   g_return_if_fail (GST_IS_PAD (pad));
4660   g_return_if_fail (foreach_func != NULL);
4661
4662   data.func = foreach_func;
4663   data.user_data = user_data;
4664
4665   GST_OBJECT_LOCK (pad);
4666   events_foreach (pad, foreach_dispatch_function, &data);
4667   GST_OBJECT_UNLOCK (pad);
4668 }
4669
4670 static void
4671 do_stream_status (GstPad * pad, GstStreamStatusType type,
4672     GThread * thread, GstTask * task)
4673 {
4674   GstElement *parent;
4675
4676   GST_DEBUG_OBJECT (pad, "doing stream-status %d", type);
4677
4678   if ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (pad)))) {
4679     if (GST_IS_ELEMENT (parent)) {
4680       GstMessage *message;
4681       GValue value = { 0 };
4682
4683       if (type == GST_STREAM_STATUS_TYPE_ENTER) {
4684         gchar *tname, *ename, *pname;
4685
4686         /* create a good task name */
4687         ename = gst_element_get_name (parent);
4688         pname = gst_pad_get_name (pad);
4689         tname = g_strdup_printf ("%s:%s", ename, pname);
4690         g_free (ename);
4691         g_free (pname);
4692
4693         gst_object_set_name (GST_OBJECT_CAST (task), tname);
4694         g_free (tname);
4695       }
4696
4697       message = gst_message_new_stream_status (GST_OBJECT_CAST (pad),
4698           type, parent);
4699
4700       g_value_init (&value, GST_TYPE_TASK);
4701       g_value_set_object (&value, task);
4702       gst_message_set_stream_status_object (message, &value);
4703       g_value_unset (&value);
4704
4705       GST_DEBUG_OBJECT (pad, "posting stream-status %d", type);
4706       gst_element_post_message (parent, message);
4707     }
4708     gst_object_unref (parent);
4709   }
4710 }
4711
4712 static void
4713 pad_enter_thread (GstTask * task, GThread * thread, gpointer user_data)
4714 {
4715   do_stream_status (GST_PAD_CAST (user_data), GST_STREAM_STATUS_TYPE_ENTER,
4716       thread, task);
4717 }
4718
4719 static void
4720 pad_leave_thread (GstTask * task, GThread * thread, gpointer user_data)
4721 {
4722   do_stream_status (GST_PAD_CAST (user_data), GST_STREAM_STATUS_TYPE_LEAVE,
4723       thread, task);
4724 }
4725
4726 static GstTaskThreadCallbacks thr_callbacks = {
4727   pad_enter_thread,
4728   pad_leave_thread,
4729 };
4730
4731 /**
4732  * gst_pad_start_task:
4733  * @pad: the #GstPad to start the task of
4734  * @func: the task function to call
4735  * @data: data passed to the task function
4736  *
4737  * Starts a task that repeatedly calls @func with @data. This function
4738  * is mostly used in pad activation functions to start the dataflow.
4739  * The #GST_PAD_STREAM_LOCK of @pad will automatically be acquired
4740  * before @func is called.
4741  *
4742  * Returns: a %TRUE if the task could be started.
4743  */
4744 gboolean
4745 gst_pad_start_task (GstPad * pad, GstTaskFunction func, gpointer data)
4746 {
4747   GstTask *task;
4748   gboolean res;
4749
4750   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
4751   g_return_val_if_fail (func != NULL, FALSE);
4752
4753   GST_DEBUG_OBJECT (pad, "start task");
4754
4755   GST_OBJECT_LOCK (pad);
4756   task = GST_PAD_TASK (pad);
4757   if (task == NULL) {
4758     task = gst_task_new (func, data);
4759     gst_task_set_lock (task, GST_PAD_GET_STREAM_LOCK (pad));
4760     gst_task_set_thread_callbacks (task, &thr_callbacks, pad, NULL);
4761     GST_DEBUG_OBJECT (pad, "created task");
4762     GST_PAD_TASK (pad) = task;
4763     gst_object_ref (task);
4764     /* release lock to post the message */
4765     GST_OBJECT_UNLOCK (pad);
4766
4767     do_stream_status (pad, GST_STREAM_STATUS_TYPE_CREATE, NULL, task);
4768
4769     gst_object_unref (task);
4770
4771     GST_OBJECT_LOCK (pad);
4772     /* nobody else is supposed to have changed the pad now */
4773     if (GST_PAD_TASK (pad) != task)
4774       goto concurrent_stop;
4775   }
4776   res = gst_task_set_state (task, GST_TASK_STARTED);
4777   GST_OBJECT_UNLOCK (pad);
4778
4779   return res;
4780
4781   /* ERRORS */
4782 concurrent_stop:
4783   {
4784     GST_OBJECT_UNLOCK (pad);
4785     return TRUE;
4786   }
4787 }
4788
4789 /**
4790  * gst_pad_pause_task:
4791  * @pad: the #GstPad to pause the task of
4792  *
4793  * Pause the task of @pad. This function will also wait until the
4794  * function executed by the task is finished if this function is not
4795  * called from the task function.
4796  *
4797  * Returns: a TRUE if the task could be paused or FALSE when the pad
4798  * has no task.
4799  */
4800 gboolean
4801 gst_pad_pause_task (GstPad * pad)
4802 {
4803   GstTask *task;
4804   gboolean res;
4805
4806   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
4807
4808   GST_DEBUG_OBJECT (pad, "pause task");
4809
4810   GST_OBJECT_LOCK (pad);
4811   task = GST_PAD_TASK (pad);
4812   if (task == NULL)
4813     goto no_task;
4814   res = gst_task_set_state (task, GST_TASK_PAUSED);
4815   GST_OBJECT_UNLOCK (pad);
4816
4817   /* wait for task function to finish, this lock is recursive so it does nothing
4818    * when the pause is called from the task itself */
4819   GST_PAD_STREAM_LOCK (pad);
4820   GST_PAD_STREAM_UNLOCK (pad);
4821
4822   return res;
4823
4824 no_task:
4825   {
4826     GST_DEBUG_OBJECT (pad, "pad has no task");
4827     GST_OBJECT_UNLOCK (pad);
4828     return FALSE;
4829   }
4830 }
4831
4832 /**
4833  * gst_pad_stop_task:
4834  * @pad: the #GstPad to stop the task of
4835  *
4836  * Stop the task of @pad. This function will also make sure that the
4837  * function executed by the task will effectively stop if not called
4838  * from the GstTaskFunction.
4839  *
4840  * This function will deadlock if called from the GstTaskFunction of
4841  * the task. Use gst_task_pause() instead.
4842  *
4843  * Regardless of whether the pad has a task, the stream lock is acquired and
4844  * released so as to ensure that streaming through this pad has finished.
4845  *
4846  * Returns: a TRUE if the task could be stopped or FALSE on error.
4847  */
4848 gboolean
4849 gst_pad_stop_task (GstPad * pad)
4850 {
4851   GstTask *task;
4852   gboolean res;
4853
4854   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
4855
4856   GST_DEBUG_OBJECT (pad, "stop task");
4857
4858   GST_OBJECT_LOCK (pad);
4859   task = GST_PAD_TASK (pad);
4860   if (task == NULL)
4861     goto no_task;
4862   GST_PAD_TASK (pad) = NULL;
4863   res = gst_task_set_state (task, GST_TASK_STOPPED);
4864   GST_OBJECT_UNLOCK (pad);
4865
4866   GST_PAD_STREAM_LOCK (pad);
4867   GST_PAD_STREAM_UNLOCK (pad);
4868
4869   if (!gst_task_join (task))
4870     goto join_failed;
4871
4872   gst_object_unref (task);
4873
4874   return res;
4875
4876 no_task:
4877   {
4878     GST_DEBUG_OBJECT (pad, "no task");
4879     GST_OBJECT_UNLOCK (pad);
4880
4881     GST_PAD_STREAM_LOCK (pad);
4882     GST_PAD_STREAM_UNLOCK (pad);
4883
4884     /* this is not an error */
4885     return TRUE;
4886   }
4887 join_failed:
4888   {
4889     /* this is bad, possibly the application tried to join the task from
4890      * the task's thread. We install the task again so that it will be stopped
4891      * again from the right thread next time hopefully. */
4892     GST_OBJECT_LOCK (pad);
4893     GST_DEBUG_OBJECT (pad, "join failed");
4894     /* we can only install this task if there was no other task */
4895     if (GST_PAD_TASK (pad) == NULL)
4896       GST_PAD_TASK (pad) = task;
4897     GST_OBJECT_UNLOCK (pad);
4898
4899     return FALSE;
4900   }
4901 }