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