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