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 "gstvalue.h"
  98 #include "glib-compat-private.h"
  99
 100 GST_DEBUG_CATEGORY_STATIC (debug_dataflow);
 101 #define GST_CAT_DEFAULT GST_CAT_PADS
 102
 103 /* Pad signals and args */
 104 enum
 105 {
 106   PAD_LINKED,
 107   PAD_UNLINKED,
 108   /* FILL ME */
 109   LAST_SIGNAL
 110 };
 111
 112 enum
 113 {
 114   PAD_PROP_0,
 115   PAD_PROP_CAPS,
 116   PAD_PROP_DIRECTION,
 117   PAD_PROP_TEMPLATE,
 118   PAD_PROP_OFFSET
 119       /* FILL ME */
 120 };
 121
 122 #define GST_PAD_GET_PRIVATE(obj)  \
 123    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_PAD, GstPadPrivate))
 124
 125 /* we have a pending and an active event on the pad. On source pads only the
 126  * active event is used. On sinkpads, events are copied to the pending entry and
 127  * moved to the active event when the eventfunc returned %TRUE. */
 128 typedef struct
 129 {
 130   gboolean received;
 131   GstEvent *event;
 132 } PadEvent;
 133
 134 struct _GstPadPrivate
 135 {
 136   guint events_cookie;
 137   GArray *events;
 138   guint last_cookie;
 139
 140   gint using;
 141   guint probe_list_cookie;
 142   guint probe_cookie;
 143
 144   /* counter of how many idle probes are running directly from the add_probe
 145    * call. Used to block any data flowing in the pad while the idle callback
 146    * Doesn't finish its work */
 147   gint idle_running;
 148 };
 149
 150 typedef struct
 151 {
 152   GHook hook;
 153   guint cookie;
 154 } GstProbe;
 155
 156 #define PROBE_COOKIE(h) (((GstProbe *)(h))->cookie)
 157 #define GST_PAD_IS_RUNNING_IDLE_PROBE(p) \
 158     (((GstPad *)(p))->priv->idle_running > 0)
 159
 160 typedef struct
 161 {
 162   GstPad *pad;
 163   GstPadProbeInfo *info;
 164   gboolean dropped;
 165   gboolean pass;
 166   gboolean handled;
 167   gboolean marshalled;
 168   guint cookie;
 169 } ProbeMarshall;
 170
 171 static void gst_pad_dispose (GObject * object);
 172 static void gst_pad_finalize (GObject * object);
 173 static void gst_pad_set_property (GObject * object, guint prop_id,
 174     const GValue * value, GParamSpec * pspec);
 175 static void gst_pad_get_property (GObject * object, guint prop_id,
 176     GValue * value, GParamSpec * pspec);
 177
 178 static void gst_pad_set_pad_template (GstPad * pad, GstPadTemplate * templ);
 179 static gboolean gst_pad_activate_default (GstPad * pad, GstObject * parent);
 180 static GstFlowReturn gst_pad_chain_list_default (GstPad * pad,
 181     GstObject * parent, GstBufferList * list);
 182
 183 static GstFlowReturn gst_pad_send_event_unchecked (GstPad * pad,
 184     GstEvent * event, GstPadProbeType type);
 185 static GstFlowReturn gst_pad_push_event_unchecked (GstPad * pad,
 186     GstEvent * event, GstPadProbeType type);
 187
 188 static guint gst_pad_signals[LAST_SIGNAL] = { 0 };
 189
 190 static GParamSpec *pspec_caps = NULL;
 191
 192 /* quarks for probe signals */
 193 static GQuark buffer_quark;
 194 static GQuark buffer_list_quark;
 195 static GQuark event_quark;
 196
 197 typedef struct
 198 {
 199   const gint ret;
 200   const gchar *name;
 201   GQuark quark;
 202 } GstFlowQuarks;
 203
 204 static GstFlowQuarks flow_quarks[] = {
 205   {GST_FLOW_CUSTOM_SUCCESS, "custom-success", 0},
 206   {GST_FLOW_OK, "ok", 0},
 207   {GST_FLOW_NOT_LINKED, "not-linked", 0},
 208   {GST_FLOW_FLUSHING, "flushing", 0},
 209   {GST_FLOW_EOS, "eos", 0},
 210   {GST_FLOW_NOT_NEGOTIATED, "not-negotiated", 0},
 211   {GST_FLOW_ERROR, "error", 0},
 212   {GST_FLOW_NOT_SUPPORTED, "not-supported", 0},
 213   {GST_FLOW_CUSTOM_ERROR, "custom-error", 0}
 214 };
 215
 216 /**
 217  * gst_flow_get_name:
 218  * @ret: a #GstFlowReturn to get the name of.
 219  *
 220  * Gets a string representing the given flow return.
 221  *
 222  * Returns: a static string with the name of the flow return.
 223  */
 224 const gchar *
 225 gst_flow_get_name (GstFlowReturn ret)
 226 {
 227   gint i;
 228
 229   ret = CLAMP (ret, GST_FLOW_CUSTOM_ERROR, GST_FLOW_CUSTOM_SUCCESS);
 230
 231   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {
 232     if (ret == flow_quarks[i].ret)
 233       return flow_quarks[i].name;
 234   }
 235   return "unknown";
 236 }
 237
 238 /**
 239  * gst_flow_to_quark:
 240  * @ret: a #GstFlowReturn to get the quark of.
 241  *
 242  * Get the unique quark for the given GstFlowReturn.
 243  *
 244  * Returns: the quark associated with the flow return or 0 if an
 245  * invalid return was specified.
 246  */
 247 GQuark
 248 gst_flow_to_quark (GstFlowReturn ret)
 249 {
 250   gint i;
 251
 252   ret = CLAMP (ret, GST_FLOW_CUSTOM_ERROR, GST_FLOW_CUSTOM_SUCCESS);
 253
 254   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {
 255     if (ret == flow_quarks[i].ret)
 256       return flow_quarks[i].quark;
 257   }
 258   return 0;
 259 }
 260
 261 /**
 262  * gst_pad_link_get_name:
 263  * @ret: a #GstPadLinkReturn to get the name of.
 264  *
 265  * Gets a string representing the given pad-link return.
 266  *
 267  * Returns: a static string with the name of the pad-link return.
 268  *
 269  * Since: 1.4
 270  */
 271 const gchar *
 272 gst_pad_link_get_name (GstPadLinkReturn ret)
 273 {
 274   switch (ret) {
 275     case GST_PAD_LINK_OK:
 276       return "ok";
 277     case GST_PAD_LINK_WRONG_HIERARCHY:
 278       return "wrong hierarchy";
 279     case GST_PAD_LINK_WAS_LINKED:
 280       return "was linked";
 281     case GST_PAD_LINK_WRONG_DIRECTION:
 282       return "wrong direction";
 283     case GST_PAD_LINK_NOFORMAT:
 284       return "no common format";
 285     case GST_PAD_LINK_NOSCHED:
 286       return "incompatible scheduling";
 287     case GST_PAD_LINK_REFUSED:
 288       return "refused";
 289   }
 290   g_return_val_if_reached ("unknown");
 291 }
 292
 293 #define _do_init \
 294 { \
 295   gint i; \
 296   \
 297   buffer_quark = g_quark_from_static_string ("buffer"); \
 298   buffer_list_quark = g_quark_from_static_string ("bufferlist"); \
 299   event_quark = g_quark_from_static_string ("event"); \
 300   \
 301   for (i = 0; i < G_N_ELEMENTS (flow_quarks); i++) {                    \
 302     flow_quarks[i].quark = g_quark_from_static_string (flow_quarks[i].name); \
 303   } \
 304   \
 305   GST_DEBUG_CATEGORY_INIT (debug_dataflow, "GST_DATAFLOW", \
 306       GST_DEBUG_BOLD | GST_DEBUG_FG_GREEN, "dataflow inside pads"); \
 307 }
 308
 309 #define gst_pad_parent_class parent_class
 310 G_DEFINE_TYPE_WITH_CODE (GstPad, gst_pad, GST_TYPE_OBJECT, _do_init);
 311
 312 static void
 313 gst_pad_class_init (GstPadClass * klass)
 314 {
 315   GObjectClass *gobject_class;
 316   GstObjectClass *gstobject_class;
 317
 318   gobject_class = G_OBJECT_CLASS (klass);
 319   gstobject_class = GST_OBJECT_CLASS (klass);
 320
 321   g_type_class_add_private (klass, sizeof (GstPadPrivate));
 322
 323   gobject_class->dispose = gst_pad_dispose;
 324   gobject_class->finalize = gst_pad_finalize;
 325   gobject_class->set_property = gst_pad_set_property;
 326   gobject_class->get_property = gst_pad_get_property;
 327
 328   /**
 329    * GstPad::linked:
 330    * @pad: the pad that emitted the signal
 331    * @peer: the peer pad that has been connected
 332    *
 333    * Signals that a pad has been linked to the peer pad.
 334    */
 335   gst_pad_signals[PAD_LINKED] =
 336       g_signal_new ("linked", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 337       G_STRUCT_OFFSET (GstPadClass, linked), NULL, NULL,
 338       g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_PAD);
 339   /**
 340    * GstPad::unlinked:
 341    * @pad: the pad that emitted the signal
 342    * @peer: the peer pad that has been disconnected
 343    *
 344    * Signals that a pad has been unlinked from the peer pad.
 345    */
 346   gst_pad_signals[PAD_UNLINKED] =
 347       g_signal_new ("unlinked", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 348       G_STRUCT_OFFSET (GstPadClass, unlinked), NULL, NULL,
 349       g_cclosure_marshal_generic, G_TYPE_NONE, 1, GST_TYPE_PAD);
 350
 351   pspec_caps = g_param_spec_boxed ("caps", "Caps",
 352       "The capabilities of the pad", GST_TYPE_CAPS,
 353       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 354   g_object_class_install_property (gobject_class, PAD_PROP_CAPS, pspec_caps);
 355
 356   g_object_class_install_property (gobject_class, PAD_PROP_DIRECTION,
 357       g_param_spec_enum ("direction", "Direction", "The direction of the pad",
 358           GST_TYPE_PAD_DIRECTION, GST_PAD_UNKNOWN,
 359           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
 360
 361   /* FIXME, Make G_PARAM_CONSTRUCT_ONLY when we fix ghostpads. */
 362   g_object_class_install_property (gobject_class, PAD_PROP_TEMPLATE,
 363       g_param_spec_object ("template", "Template",
 364           "The GstPadTemplate of this pad", GST_TYPE_PAD_TEMPLATE,
 365           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 366
 367   /**
 368    * GstPad:offset:
 369    *
 370    * The offset that will be applied to the running time of the pad.
 371    *
 372    * Since: 1.6
 373    */
 374   g_object_class_install_property (gobject_class, PAD_PROP_OFFSET,
 375       g_param_spec_int64 ("offset", "Offset",
 376           "The running time offset of the pad", 0, G_MAXINT64, 0,
 377           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 378
 379   gstobject_class->path_string_separator = ".";
 380
 381   /* Register common function pointer descriptions */
 382   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_activate_default);
 383   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_event_default);
 384   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_query_default);
 385   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_iterate_internal_links_default);
 386   GST_DEBUG_REGISTER_FUNCPTR (gst_pad_chain_list_default);
 387 }
 388
 389 static void
 390 gst_pad_init (GstPad * pad)
 391 {
 392   pad->priv = GST_PAD_GET_PRIVATE (pad);
 393
 394   GST_PAD_DIRECTION (pad) = GST_PAD_UNKNOWN;
 395
 396   GST_PAD_ACTIVATEFUNC (pad) = gst_pad_activate_default;
 397   GST_PAD_EVENTFUNC (pad) = gst_pad_event_default;
 398   GST_PAD_QUERYFUNC (pad) = gst_pad_query_default;
 399   GST_PAD_ITERINTLINKFUNC (pad) = gst_pad_iterate_internal_links_default;
 400   GST_PAD_CHAINLISTFUNC (pad) = gst_pad_chain_list_default;
 401
 402   GST_PAD_SET_FLUSHING (pad);
 403
 404   g_rec_mutex_init (&pad->stream_rec_lock);
 405
 406   g_cond_init (&pad->block_cond);
 407
 408   g_hook_list_init (&pad->probes, sizeof (GstProbe));
 409
 410   pad->priv->events = g_array_sized_new (FALSE, TRUE, sizeof (PadEvent), 16);
 411   pad->priv->events_cookie = 0;
 412   pad->priv->last_cookie = -1;
 413   pad->ABI.abi.last_flowret = GST_FLOW_FLUSHING;
 414 }
 415
 416 /* called when setting the pad inactive. It removes all sticky events from
 417  * the pad. must be called with object lock */
 418 static void
 419 remove_events (GstPad * pad)
 420 {
 421   guint i, len;
 422   GArray *events;
 423   gboolean notify = FALSE;
 424
 425   events = pad->priv->events;
 426
 427   len = events->len;
 428   for (i = 0; i < len; i++) {
 429     PadEvent *ev = &g_array_index (events, PadEvent, i);
 430     GstEvent *event = ev->event;
 431
 432     ev->event = NULL;
 433
 434     if (event && GST_EVENT_TYPE (event) == GST_EVENT_CAPS)
 435       notify = TRUE;
 436
 437     gst_event_unref (event);
 438   }
 439
 440   GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PENDING_EVENTS);
 441   g_array_set_size (events, 0);
 442   pad->priv->events_cookie++;
 443
 444   if (notify) {
 445     GST_OBJECT_UNLOCK (pad);
 446
 447     GST_DEBUG_OBJECT (pad, "notify caps");
 448     g_object_notify_by_pspec ((GObject *) pad, pspec_caps);
 449
 450     GST_OBJECT_LOCK (pad);
 451   }
 452 }
 453
 454 /* should be called with object lock */
 455 static PadEvent *
 456 find_event_by_type (GstPad * pad, GstEventType type, guint idx)
 457 {
 458   guint i, len;
 459   GArray *events;
 460   PadEvent *ev;
 461
 462   events = pad->priv->events;
 463   len = events->len;
 464
 465   for (i = 0; i < len; i++) {
 466     ev = &g_array_index (events, PadEvent, i);
 467     if (ev->event == NULL)
 468       continue;
 469
 470     if (GST_EVENT_TYPE (ev->event) == type) {
 471       if (idx == 0)
 472         goto found;
 473       idx--;
 474     } else if (GST_EVENT_TYPE (ev->event) > type) {
 475       break;
 476     }
 477   }
 478   ev = NULL;
 479 found:
 480   return ev;
 481 }
 482
 483 /* should be called with OBJECT lock */
 484 static PadEvent *
 485 find_event (GstPad * pad, GstEvent * event)
 486 {
 487   guint i, len;
 488   GArray *events;
 489   PadEvent *ev;
 490
 491   events = pad->priv->events;
 492   len = events->len;
 493
 494   for (i = 0; i < len; i++) {
 495     ev = &g_array_index (events, PadEvent, i);
 496     if (event == ev->event)
 497       goto found;
 498     else if (GST_EVENT_TYPE (ev->event) > GST_EVENT_TYPE (event))
 499       break;
 500   }
 501   ev = NULL;
 502 found:
 503   return ev;
 504 }
 505
 506 /* should be called with OBJECT lock */
 507 static void
 508 remove_event_by_type (GstPad * pad, GstEventType type)
 509 {
 510   guint i, len;
 511   GArray *events;
 512   PadEvent *ev;
 513
 514   events = pad->priv->events;
 515   len = events->len;
 516
 517   i = 0;
 518   while (i < len) {
 519     ev = &g_array_index (events, PadEvent, i);
 520     if (ev->event == NULL)
 521       goto next;
 522
 523     if (GST_EVENT_TYPE (ev->event) > type)
 524       break;
 525     else if (GST_EVENT_TYPE (ev->event) != type)
 526       goto next;
 527
 528     gst_event_unref (ev->event);
 529     g_array_remove_index (events, i);
 530     len--;
 531     pad->priv->events_cookie++;
 532     continue;
 533
 534   next:
 535     i++;
 536   }
 537 }
 538
 539 /* check all events on srcpad against those on sinkpad. All events that are not
 540  * on sinkpad are marked as received=%FALSE and the PENDING_EVENTS is set on the
 541  * srcpad so that the events will be sent next time */
 542 /* should be called with srcpad and sinkpad LOCKS */
 543 static void
 544 schedule_events (GstPad * srcpad, GstPad * sinkpad)
 545 {
 546   gint i, len;
 547   GArray *events;
 548   PadEvent *ev;
 549   gboolean pending = FALSE;
 550
 551   events = srcpad->priv->events;
 552   len = events->len;
 553
 554   for (i = 0; i < len; i++) {
 555     ev = &g_array_index (events, PadEvent, i);
 556     if (ev->event == NULL)
 557       continue;
 558
 559     if (sinkpad == NULL || !find_event (sinkpad, ev->event)) {
 560       ev->received = FALSE;
 561       pending = TRUE;
 562     }
 563   }
 564   if (pending)
 565     GST_OBJECT_FLAG_SET (srcpad, GST_PAD_FLAG_PENDING_EVENTS);
 566 }
 567
 568 typedef gboolean (*PadEventFunction) (GstPad * pad, PadEvent * ev,
 569     gpointer user_data);
 570
 571 /* should be called with pad LOCK */
 572 static void
 573 events_foreach (GstPad * pad, PadEventFunction func, gpointer user_data)
 574 {
 575   guint i, len;
 576   GArray *events;
 577   gboolean ret;
 578   guint cookie;
 579
 580   events = pad->priv->events;
 581
 582 restart:
 583   cookie = pad->priv->events_cookie;
 584   i = 0;
 585   len = events->len;
 586   while (i < len) {
 587     PadEvent *ev, ev_ret;
 588
 589     ev = &g_array_index (events, PadEvent, i);
 590     if (G_UNLIKELY (ev->event == NULL))
 591       goto next;
 592
 593     /* take aditional ref, func might release the lock */
 594     ev_ret.event = gst_event_ref (ev->event);
 595     ev_ret.received = ev->received;
 596
 597     ret = func (pad, &ev_ret, user_data);
 598
 599     /* recheck the cookie, lock might have been released and the list could have
 600      * changed */
 601     if (G_UNLIKELY (cookie != pad->priv->events_cookie)) {
 602       if (G_LIKELY (ev_ret.event))
 603         gst_event_unref (ev_ret.event);
 604       goto restart;
 605     }
 606
 607     /* store the received state */
 608     ev->received = ev_ret.received;
 609
 610     /* if the event changed, we need to do something */
 611     if (G_UNLIKELY (ev->event != ev_ret.event)) {
 612       if (G_UNLIKELY (ev_ret.event == NULL)) {
 613         /* function unreffed and set the event to NULL, remove it */
 614         gst_event_unref (ev->event);
 615         g_array_remove_index (events, i);
 616         len--;
 617         cookie = ++pad->priv->events_cookie;
 618         continue;
 619       } else {
 620         /* function gave a new event for us */
 621         gst_event_take (&ev->event, ev_ret.event);
 622       }
 623     } else {
 624       /* just unref, nothing changed */
 625       gst_event_unref (ev_ret.event);
 626     }
 627     if (!ret)
 628       break;
 629   next:
 630     i++;
 631   }
 632 }
 633
 634 /* should be called with LOCK */
 635 static GstEvent *
 636 _apply_pad_offset (GstPad * pad, GstEvent * event, gboolean upstream)
 637 {
 638   gint64 offset;
 639
 640   GST_DEBUG_OBJECT (pad, "apply pad offset %" GST_TIME_FORMAT,
 641       GST_TIME_ARGS (pad->offset));
 642
 643   if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) {
 644     GstSegment segment;
 645
 646     g_assert (!upstream);
 647
 648     /* copy segment values */
 649     gst_event_copy_segment (event, &segment);
 650     gst_event_unref (event);
 651
 652     gst_segment_offset_running_time (&segment, segment.format, pad->offset);
 653     event = gst_event_new_segment (&segment);
 654   }
 655
 656   event = gst_event_make_writable (event);
 657   offset = gst_event_get_running_time_offset (event);
 658   if (upstream)
 659     offset -= pad->offset;
 660   else
 661     offset += pad->offset;
 662   gst_event_set_running_time_offset (event, offset);
 663
 664   return event;
 665 }
 666
 667 static inline GstEvent *
 668 apply_pad_offset (GstPad * pad, GstEvent * event, gboolean upstream)
 669 {
 670   if (G_UNLIKELY (pad->offset != 0))
 671     return _apply_pad_offset (pad, event, upstream);
 672   return event;
 673 }
 674
 675
 676 /* should be called with the OBJECT_LOCK */
 677 static GstCaps *
 678 get_pad_caps (GstPad * pad)
 679 {
 680   GstCaps *caps = NULL;
 681   PadEvent *ev;
 682
 683   ev = find_event_by_type (pad, GST_EVENT_CAPS, 0);
 684   if (ev && ev->event)
 685     gst_event_parse_caps (ev->event, &caps);
 686
 687   return caps;
 688 }
 689
 690 static void
 691 gst_pad_dispose (GObject * object)
 692 {
 693   GstPad *pad = GST_PAD_CAST (object);
 694   GstPad *peer;
 695
 696   GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, pad, "dispose");
 697
 698   /* unlink the peer pad */
 699   if ((peer = gst_pad_get_peer (pad))) {
 700     /* window for MT unsafeness, someone else could unlink here
 701      * and then we call unlink with wrong pads. The unlink
 702      * function would catch this and safely return failed. */
 703     if (GST_PAD_IS_SRC (pad))
 704       gst_pad_unlink (pad, peer);
 705     else
 706       gst_pad_unlink (peer, pad);
 707
 708     gst_object_unref (peer);
 709   }
 710
 711   gst_pad_set_pad_template (pad, NULL);
 712
 713   GST_OBJECT_LOCK (pad);
 714   remove_events (pad);
 715   GST_OBJECT_UNLOCK (pad);
 716
 717   g_hook_list_clear (&pad->probes);
 718
 719   G_OBJECT_CLASS (parent_class)->dispose (object);
 720 }
 721
 722 static void
 723 gst_pad_finalize (GObject * object)
 724 {
 725   GstPad *pad = GST_PAD_CAST (object);
 726   GstTask *task;
 727
 728   /* in case the task is still around, clean it up */
 729   if ((task = GST_PAD_TASK (pad))) {
 730     gst_task_join (task);
 731     GST_PAD_TASK (pad) = NULL;
 732     gst_object_unref (task);
 733   }
 734
 735   if (pad->activatenotify)
 736     pad->activatenotify (pad->activatedata);
 737   if (pad->activatemodenotify)
 738     pad->activatemodenotify (pad->activatemodedata);
 739   if (pad->linknotify)
 740     pad->linknotify (pad->linkdata);
 741   if (pad->unlinknotify)
 742     pad->unlinknotify (pad->unlinkdata);
 743   if (pad->chainnotify)
 744     pad->chainnotify (pad->chaindata);
 745   if (pad->chainlistnotify)
 746     pad->chainlistnotify (pad->chainlistdata);
 747   if (pad->getrangenotify)
 748     pad->getrangenotify (pad->getrangedata);
 749   if (pad->eventnotify)
 750     pad->eventnotify (pad->eventdata);
 751   if (pad->querynotify)
 752     pad->querynotify (pad->querydata);
 753   if (pad->iterintlinknotify)
 754     pad->iterintlinknotify (pad->iterintlinkdata);
 755
 756   g_rec_mutex_clear (&pad->stream_rec_lock);
 757   g_cond_clear (&pad->block_cond);
 758   g_array_free (pad->priv->events, TRUE);
 759
 760   G_OBJECT_CLASS (parent_class)->finalize (object);
 761 }
 762
 763 static void
 764 gst_pad_set_property (GObject * object, guint prop_id,
 765     const GValue * value, GParamSpec * pspec)
 766 {
 767   g_return_if_fail (GST_IS_PAD (object));
 768
 769   switch (prop_id) {
 770     case PAD_PROP_DIRECTION:
 771       GST_PAD_DIRECTION (object) = (GstPadDirection) g_value_get_enum (value);
 772       break;
 773     case PAD_PROP_TEMPLATE:
 774       gst_pad_set_pad_template (GST_PAD_CAST (object),
 775           (GstPadTemplate *) g_value_get_object (value));
 776       break;
 777     case PAD_PROP_OFFSET:
 778       gst_pad_set_offset (GST_PAD_CAST (object), g_value_get_int64 (value));
 779       break;
 780     default:
 781       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 782       break;
 783   }
 784 }
 785
 786 static void
 787 gst_pad_get_property (GObject * object, guint prop_id,
 788     GValue * value, GParamSpec * pspec)
 789 {
 790   g_return_if_fail (GST_IS_PAD (object));
 791
 792   switch (prop_id) {
 793     case PAD_PROP_CAPS:
 794       GST_OBJECT_LOCK (object);
 795       g_value_set_boxed (value, get_pad_caps (GST_PAD_CAST (object)));
 796       GST_OBJECT_UNLOCK (object);
 797       break;
 798     case PAD_PROP_DIRECTION:
 799       g_value_set_enum (value, GST_PAD_DIRECTION (object));
 800       break;
 801     case PAD_PROP_TEMPLATE:
 802       g_value_set_object (value, GST_PAD_PAD_TEMPLATE (object));
 803       break;
 804     case PAD_PROP_OFFSET:
 805       g_value_set_int64 (value, gst_pad_get_offset (GST_PAD_CAST (object)));
 806       break;
 807     default:
 808       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 809       break;
 810   }
 811 }
 812
 813 /**
 814  * gst_pad_new:
 815  * @name: (allow-none): the name of the new pad.
 816  * @direction: the #GstPadDirection of the pad.
 817  *
 818  * Creates a new pad with the given name in the given direction.
 819  * If name is %NULL, a guaranteed unique name (across all pads)
 820  * will be assigned.
 821  * This function makes a copy of the name so you can safely free the name.
 822  *
 823  * Returns: (transfer floating) (nullable): a new #GstPad, or %NULL in
 824  * case of an error.
 825  *
 826  * MT safe.
 827  */
 828 GstPad *
 829 gst_pad_new (const gchar * name, GstPadDirection direction)
 830 {
 831   return g_object_new (GST_TYPE_PAD,
 832       "name", name, "direction", direction, NULL);
 833 }
 834
 835 /**
 836  * gst_pad_new_from_template:
 837  * @templ: the pad template to use
 838  * @name: (allow-none): the name of the pad
 839  *
 840  * Creates a new pad with the given name from the given template.
 841  * If name is %NULL, a guaranteed unique name (across all pads)
 842  * will be assigned.
 843  * This function makes a copy of the name so you can safely free the name.
 844  *
 845  * Returns: (transfer floating) (nullable): a new #GstPad, or %NULL in
 846  * case of an error.
 847  */
 848 GstPad *
 849 gst_pad_new_from_template (GstPadTemplate * templ, const gchar * name)
 850 {
 851   g_return_val_if_fail (GST_IS_PAD_TEMPLATE (templ), NULL);
 852
 853   return g_object_new (GST_TYPE_PAD,
 854       "name", name, "direction", templ->direction, "template", templ, NULL);
 855 }
 856
 857 /**
 858  * gst_pad_new_from_static_template:
 859  * @templ: the #GstStaticPadTemplate to use
 860  * @name: the name of the pad
 861  *
 862  * Creates a new pad with the given name from the given static template.
 863  * If name is %NULL, a guaranteed unique name (across all pads)
 864  * will be assigned.
 865  * This function makes a copy of the name so you can safely free the name.
 866  *
 867  * Returns: (transfer floating) (nullable): a new #GstPad, or %NULL in
 868  * case of an error.
 869  */
 870 GstPad *
 871 gst_pad_new_from_static_template (GstStaticPadTemplate * templ,
 872     const gchar * name)
 873 {
 874   GstPad *pad;
 875   GstPadTemplate *template;
 876
 877   template = gst_static_pad_template_get (templ);
 878   pad = gst_pad_new_from_template (template, name);
 879   gst_object_unref (template);
 880   return pad;
 881 }
 882
 883 #define ACQUIRE_PARENT(pad, parent, label)                      \
 884   G_STMT_START {                                                \
 885     if (G_LIKELY ((parent = GST_OBJECT_PARENT (pad))))          \
 886       gst_object_ref (parent);                                  \
 887     else if (G_LIKELY (GST_PAD_NEEDS_PARENT (pad)))             \
 888       goto label;                                               \
 889   } G_STMT_END
 890
 891 #define RELEASE_PARENT(parent)                                  \
 892   G_STMT_START {                                                \
 893     if (G_LIKELY (parent))                                      \
 894       gst_object_unref (parent);                                \
 895   } G_STMT_END
 896
 897 /**
 898  * gst_pad_get_direction:
 899  * @pad: a #GstPad to get the direction of.
 900  *
 901  * Gets the direction of the pad. The direction of the pad is
 902  * decided at construction time so this function does not take
 903  * the LOCK.
 904  *
 905  * Returns: the #GstPadDirection of the pad.
 906  *
 907  * MT safe.
 908  */
 909 GstPadDirection
 910 gst_pad_get_direction (GstPad * pad)
 911 {
 912   GstPadDirection result;
 913
 914   /* PAD_UNKNOWN is a little silly but we need some sort of
 915    * error return value */
 916   g_return_val_if_fail (GST_IS_PAD (pad), GST_PAD_UNKNOWN);
 917
 918   result = GST_PAD_DIRECTION (pad);
 919
 920   return result;
 921 }
 922
 923 static gboolean
 924 gst_pad_activate_default (GstPad * pad, GstObject * parent)
 925 {
 926   return gst_pad_activate_mode (pad, GST_PAD_MODE_PUSH, TRUE);
 927 }
 928
 929 /**
 930  * gst_pad_mode_get_name:
 931  * @mode: the pad mode
 932  *
 933  * Return the name of a pad mode, for use in debug messages mostly.
 934  *
 935  * Returns: short mnemonic for pad mode @mode
 936  */
 937 const gchar *
 938 gst_pad_mode_get_name (GstPadMode mode)
 939 {
 940   switch (mode) {
 941     case GST_PAD_MODE_NONE:
 942       return "none";
 943     case GST_PAD_MODE_PUSH:
 944       return "push";
 945     case GST_PAD_MODE_PULL:
 946       return "pull";
 947     default:
 948       break;
 949   }
 950   return "unknown";
 951 }
 952
 953 static void
 954 pre_activate (GstPad * pad, GstPadMode new_mode)
 955 {
 956   switch (new_mode) {
 957     case GST_PAD_MODE_NONE:
 958       GST_OBJECT_LOCK (pad);
 959       GST_DEBUG_OBJECT (pad, "setting PAD_MODE NONE, set flushing");
 960       GST_PAD_SET_FLUSHING (pad);
 961       pad->ABI.abi.last_flowret = GST_FLOW_FLUSHING;
 962       GST_PAD_MODE (pad) = new_mode;
 963       /* unlock blocked pads so element can resume and stop */
 964       GST_PAD_BLOCK_BROADCAST (pad);
 965       GST_OBJECT_UNLOCK (pad);
 966       break;
 967     case GST_PAD_MODE_PUSH:
 968     case GST_PAD_MODE_PULL:
 969       GST_OBJECT_LOCK (pad);
 970       GST_DEBUG_OBJECT (pad, "setting pad into %s mode, unset flushing",
 971           gst_pad_mode_get_name (new_mode));
 972       GST_PAD_UNSET_FLUSHING (pad);
 973       pad->ABI.abi.last_flowret = GST_FLOW_OK;
 974       GST_PAD_MODE (pad) = new_mode;
 975       if (GST_PAD_IS_SINK (pad)) {
 976         GstPad *peer;
 977         /* make sure the peer src pad sends us all events */
 978         if ((peer = GST_PAD_PEER (pad))) {
 979           gst_object_ref (peer);
 980           GST_OBJECT_UNLOCK (pad);
 981
 982           GST_DEBUG_OBJECT (pad, "reschedule events on peer %s:%s",
 983               GST_DEBUG_PAD_NAME (peer));
 984
 985           GST_OBJECT_LOCK (peer);
 986           schedule_events (peer, NULL);
 987           GST_OBJECT_UNLOCK (peer);
 988
 989           gst_object_unref (peer);
 990         } else {
 991           GST_OBJECT_UNLOCK (pad);
 992         }
 993       } else {
 994         GST_OBJECT_UNLOCK (pad);
 995       }
 996       break;
 997   }
 998 }
 999
1000 static void
1001 post_activate (GstPad * pad, GstPadMode new_mode)
1002 {
1003   switch (new_mode) {
1004     case GST_PAD_MODE_NONE:
1005       /* ensures that streaming stops */
1006       GST_PAD_STREAM_LOCK (pad);
1007       GST_DEBUG_OBJECT (pad, "stopped streaming");
1008       GST_OBJECT_LOCK (pad);
1009       remove_events (pad);
1010       GST_OBJECT_UNLOCK (pad);
1011       GST_PAD_STREAM_UNLOCK (pad);
1012       break;
1013     case GST_PAD_MODE_PUSH:
1014     case GST_PAD_MODE_PULL:
1015       /* NOP */
1016       break;
1017   }
1018 }
1019
1020 /**
1021  * gst_pad_set_active:
1022  * @pad: the #GstPad to activate or deactivate.
1023  * @active: whether or not the pad should be active.
1024  *
1025  * Activates or deactivates the given pad.
1026  * Normally called from within core state change functions.
1027  *
1028  * If @active, makes sure the pad is active. If it is already active, either in
1029  * push or pull mode, just return. Otherwise dispatches to the pad's activate
1030  * function to perform the actual activation.
1031  *
1032  * If not @active, calls gst_pad_activate_mode() with the pad's current mode
1033  * and a %FALSE argument.
1034  *
1035  * Returns: %TRUE if the operation was successful.
1036  *
1037  * MT safe.
1038  */
1039 gboolean
1040 gst_pad_set_active (GstPad * pad, gboolean active)
1041 {
1042   GstObject *parent;
1043   GstPadMode old;
1044   gboolean ret = FALSE;
1045
1046   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1047
1048   GST_OBJECT_LOCK (pad);
1049   old = GST_PAD_MODE (pad);
1050   ACQUIRE_PARENT (pad, parent, no_parent);
1051   GST_OBJECT_UNLOCK (pad);
1052
1053   if (active) {
1054     if (old == GST_PAD_MODE_NONE) {
1055       GST_DEBUG_OBJECT (pad, "activating pad from none");
1056       ret = (GST_PAD_ACTIVATEFUNC (pad)) (pad, parent);
1057       if (ret)
1058         pad->ABI.abi.last_flowret = GST_FLOW_OK;
1059     } else {
1060       GST_DEBUG_OBJECT (pad, "pad was active in %s mode",
1061           gst_pad_mode_get_name (old));
1062       ret = TRUE;
1063     }
1064   } else {
1065     if (old == GST_PAD_MODE_NONE) {
1066       GST_DEBUG_OBJECT (pad, "pad was inactive");
1067       ret = TRUE;
1068     } else {
1069       GST_DEBUG_OBJECT (pad, "deactivating pad from %s mode",
1070           gst_pad_mode_get_name (old));
1071       ret = gst_pad_activate_mode (pad, old, FALSE);
1072       if (ret)
1073         pad->ABI.abi.last_flowret = GST_FLOW_FLUSHING;
1074     }
1075   }
1076
1077   RELEASE_PARENT (parent);
1078
1079   if (G_UNLIKELY (!ret))
1080     goto failed;
1081
1082   return ret;
1083
1084   /* ERRORS */
1085 no_parent:
1086   {
1087     GST_DEBUG_OBJECT (pad, "no parent");
1088     GST_OBJECT_UNLOCK (pad);
1089     return FALSE;
1090   }
1091 failed:
1092   {
1093     GST_OBJECT_LOCK (pad);
1094     if (!active) {
1095       g_critical ("Failed to deactivate pad %s:%s, very bad",
1096           GST_DEBUG_PAD_NAME (pad));
1097     } else {
1098       GST_WARNING_OBJECT (pad, "Failed to activate pad");
1099     }
1100     GST_OBJECT_UNLOCK (pad);
1101     return FALSE;
1102   }
1103 }
1104
1105 /**
1106  * gst_pad_activate_mode:
1107  * @pad: the #GstPad to activate or deactivate.
1108  * @mode: the requested activation mode
1109  * @active: whether or not the pad should be active.
1110  *
1111  * Activates or deactivates the given pad in @mode via dispatching to the
1112  * pad's activatemodefunc. For use from within pad activation functions only.
1113  *
1114  * If you don't know what this is, you probably don't want to call it.
1115  *
1116  * Returns: %TRUE if the operation was successful.
1117  *
1118  * MT safe.
1119  */
1120 gboolean
1121 gst_pad_activate_mode (GstPad * pad, GstPadMode mode, gboolean active)
1122 {
1123   gboolean res = FALSE;
1124   GstObject *parent;
1125   GstPadMode old, new;
1126   GstPadDirection dir;
1127   GstPad *peer;
1128
1129   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1130
1131   GST_OBJECT_LOCK (pad);
1132   old = GST_PAD_MODE (pad);
1133   dir = GST_PAD_DIRECTION (pad);
1134   ACQUIRE_PARENT (pad, parent, no_parent);
1135   GST_OBJECT_UNLOCK (pad);
1136
1137   new = active ? mode : GST_PAD_MODE_NONE;
1138
1139   if (old == new)
1140     goto was_ok;
1141
1142   if (active && old != mode && old != GST_PAD_MODE_NONE) {
1143     /* pad was activate in the wrong direction, deactivate it
1144      * and reactivate it in the requested mode */
1145     GST_DEBUG_OBJECT (pad, "deactivating pad from %s mode",
1146         gst_pad_mode_get_name (old));
1147
1148     if (G_UNLIKELY (!gst_pad_activate_mode (pad, old, FALSE)))
1149       goto deactivate_failed;
1150   }
1151
1152   switch (mode) {
1153     case GST_PAD_MODE_PULL:
1154     {
1155       if (dir == GST_PAD_SINK) {
1156         if ((peer = gst_pad_get_peer (pad))) {
1157           GST_DEBUG_OBJECT (pad, "calling peer");
1158           if (G_UNLIKELY (!gst_pad_activate_mode (peer, mode, active)))
1159             goto peer_failed;
1160           gst_object_unref (peer);
1161         } else {
1162           /* there is no peer, this is only fatal when we activate. When we
1163            * deactivate, we must assume the application has unlinked the peer and
1164            * will deactivate it eventually. */
1165           if (active)
1166             goto not_linked;
1167           else
1168             GST_DEBUG_OBJECT (pad, "deactivating unlinked pad");
1169         }
1170       } else {
1171         if (G_UNLIKELY (GST_PAD_GETRANGEFUNC (pad) == NULL))
1172           goto failure;         /* Can't activate pull on a src without a
1173                                    getrange function */
1174       }
1175       break;
1176     }
1177     default:
1178       break;
1179   }
1180
1181   /* Mark pad as needing reconfiguration */
1182   if (active)
1183     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
1184   pre_activate (pad, new);
1185
1186   if (GST_PAD_ACTIVATEMODEFUNC (pad)) {
1187     if (G_UNLIKELY (!GST_PAD_ACTIVATEMODEFUNC (pad) (pad, parent, mode,
1188                 active)))
1189       goto failure;
1190   } else {
1191     /* can happen for sinks of passthrough elements */
1192   }
1193
1194   post_activate (pad, new);
1195
1196   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "%s in %s mode",
1197       active ? "activated" : "deactivated", gst_pad_mode_get_name (mode));
1198
1199 exit_success:
1200   res = TRUE;
1201
1202   /* Clear sticky flags on deactivation */
1203   if (!active) {
1204     GST_OBJECT_LOCK (pad);
1205     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
1206     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_EOS);
1207     GST_OBJECT_UNLOCK (pad);
1208   }
1209
1210 exit:
1211   RELEASE_PARENT (parent);
1212
1213   return res;
1214
1215 no_parent:
1216   {
1217     GST_DEBUG_OBJECT (pad, "no parent");
1218     GST_OBJECT_UNLOCK (pad);
1219     return FALSE;
1220   }
1221 was_ok:
1222   {
1223     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "already %s in %s mode",
1224         active ? "activated" : "deactivated", gst_pad_mode_get_name (mode));
1225     goto exit_success;
1226   }
1227 deactivate_failed:
1228   {
1229     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
1230         "failed to %s in switch to %s mode from %s mode",
1231         (active ? "activate" : "deactivate"), gst_pad_mode_get_name (mode),
1232         gst_pad_mode_get_name (old));
1233     goto exit;
1234   }
1235 peer_failed:
1236   {
1237     GST_OBJECT_LOCK (peer);
1238     GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad,
1239         "activate_mode on peer (%s:%s) failed", GST_DEBUG_PAD_NAME (peer));
1240     GST_OBJECT_UNLOCK (peer);
1241     gst_object_unref (peer);
1242     goto exit;
1243   }
1244 not_linked:
1245   {
1246     GST_CAT_INFO_OBJECT (GST_CAT_PADS, pad, "can't activate unlinked sink "
1247         "pad in pull mode");
1248     goto exit;
1249   }
1250 failure:
1251   {
1252     GST_OBJECT_LOCK (pad);
1253     GST_CAT_INFO_OBJECT (GST_CAT_PADS, pad, "failed to %s in %s mode",
1254         active ? "activate" : "deactivate", gst_pad_mode_get_name (mode));
1255     GST_PAD_SET_FLUSHING (pad);
1256     GST_PAD_MODE (pad) = old;
1257     GST_OBJECT_UNLOCK (pad);
1258     goto exit;
1259   }
1260 }
1261
1262 /**
1263  * gst_pad_is_active:
1264  * @pad: the #GstPad to query
1265  *
1266  * Query if a pad is active
1267  *
1268  * Returns: %TRUE if the pad is active.
1269  *
1270  * MT safe.
1271  */
1272 gboolean
1273 gst_pad_is_active (GstPad * pad)
1274 {
1275   gboolean result = FALSE;
1276
1277   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1278
1279   GST_OBJECT_LOCK (pad);
1280   result = GST_PAD_IS_ACTIVE (pad);
1281   GST_OBJECT_UNLOCK (pad);
1282
1283   return result;
1284 }
1285
1286 static void
1287 cleanup_hook (GstPad * pad, GHook * hook)
1288 {
1289   GstPadProbeType type;
1290
1291   if (!G_HOOK_IS_VALID (hook))
1292     return;
1293
1294   type = (hook->flags) >> G_HOOK_FLAG_USER_SHIFT;
1295
1296   if (type & GST_PAD_PROBE_TYPE_BLOCKING) {
1297     /* unblock when we remove the last blocking probe */
1298     pad->num_blocked--;
1299     GST_DEBUG_OBJECT (pad, "remove blocking probe, now %d left",
1300         pad->num_blocked);
1301
1302     /* Might have new probes now that want to be called */
1303     GST_PAD_BLOCK_BROADCAST (pad);
1304
1305     if (pad->num_blocked == 0) {
1306       GST_DEBUG_OBJECT (pad, "last blocking probe removed, unblocking");
1307       GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_BLOCKED);
1308     }
1309   }
1310   g_hook_destroy_link (&pad->probes, hook);
1311   pad->num_probes--;
1312 }
1313
1314 /**
1315  * gst_pad_add_probe:
1316  * @pad: the #GstPad to add the probe to
1317  * @mask: the probe mask
1318  * @callback: #GstPadProbeCallback that will be called with notifications of
1319  *           the pad state
1320  * @user_data: (closure): user data passed to the callback
1321  * @destroy_data: #GDestroyNotify for user_data
1322  *
1323  * Be notified of different states of pads. The provided callback is called for
1324  * every state that matches @mask.
1325  *
1326  * Returns: an id or 0 if no probe is pending. The id can be used to remove the
1327  * probe with gst_pad_remove_probe(). When using GST_PAD_PROBE_TYPE_IDLE it can
1328  * happen that the probe can be run immediately and if the probe returns
1329  * GST_PAD_PROBE_REMOVE this functions returns 0.
1330  *
1331  * MT safe.
1332  */
1333 gulong
1334 gst_pad_add_probe (GstPad * pad, GstPadProbeType mask,
1335     GstPadProbeCallback callback, gpointer user_data,
1336     GDestroyNotify destroy_data)
1337 {
1338   GHook *hook;
1339   gulong res;
1340
1341   g_return_val_if_fail (GST_IS_PAD (pad), 0);
1342   g_return_val_if_fail (mask != 0, 0);
1343
1344   GST_OBJECT_LOCK (pad);
1345
1346   /* make a new probe */
1347   hook = g_hook_alloc (&pad->probes);
1348
1349   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "adding probe for mask 0x%08x",
1350       mask);
1351
1352   /* when no contraints are given for the types, assume all types are
1353    * acceptable */
1354   if ((mask & GST_PAD_PROBE_TYPE_ALL_BOTH) == 0)
1355     mask |= GST_PAD_PROBE_TYPE_ALL_BOTH;
1356   if ((mask & GST_PAD_PROBE_TYPE_SCHEDULING) == 0)
1357     mask |= GST_PAD_PROBE_TYPE_SCHEDULING;
1358
1359   /* store our flags and other fields */
1360   hook->flags |= (mask << G_HOOK_FLAG_USER_SHIFT);
1361   hook->func = callback;
1362   hook->data = user_data;
1363   hook->destroy = destroy_data;
1364   PROBE_COOKIE (hook) = (pad->priv->probe_cookie - 1);
1365
1366   /* add the probe */
1367   g_hook_prepend (&pad->probes, hook);
1368   pad->num_probes++;
1369   /* incremenent cookie so that the new hook get's called */
1370   pad->priv->probe_list_cookie++;
1371
1372   /* get the id of the hook, we return this and it can be used to remove the
1373    * probe later */
1374   res = hook->hook_id;
1375
1376   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "got probe id %lu", res);
1377
1378   if (mask & GST_PAD_PROBE_TYPE_BLOCKING) {
1379     /* we have a block probe */
1380     pad->num_blocked++;
1381     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_BLOCKED);
1382     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "added blocking probe, "
1383         "now %d blocking probes", pad->num_blocked);
1384
1385     /* Might have new probes now that want to be called */
1386     GST_PAD_BLOCK_BROADCAST (pad);
1387   }
1388
1389   /* call the callback if we need to be called for idle callbacks */
1390   if ((mask & GST_PAD_PROBE_TYPE_IDLE) && (callback != NULL)) {
1391     if (pad->priv->using > 0) {
1392       /* the pad is in use, we can't signal the idle callback yet. Since we set the
1393        * flag above, the last thread to leave the push will do the callback. New
1394        * threads going into the push will block. */
1395       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
1396           "pad is in use, delay idle callback");
1397       GST_OBJECT_UNLOCK (pad);
1398     } else {
1399       GstPadProbeInfo info = { GST_PAD_PROBE_TYPE_IDLE, res, };
1400       GstPadProbeReturn ret;
1401
1402       /* Keep another ref, the callback could destroy the pad */
1403       gst_object_ref (pad);
1404       pad->priv->idle_running++;
1405
1406       /* the pad is idle now, we can signal the idle callback now */
1407       GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
1408           "pad is idle, trigger idle callback");
1409       GST_OBJECT_UNLOCK (pad);
1410
1411       ret = callback (pad, &info, user_data);
1412
1413       GST_OBJECT_LOCK (pad);
1414       switch (ret) {
1415         case GST_PAD_PROBE_REMOVE:
1416           /* remove the probe */
1417           GST_DEBUG_OBJECT (pad, "asked to remove hook");
1418           cleanup_hook (pad, hook);
1419           res = 0;
1420           break;
1421         case GST_PAD_PROBE_DROP:
1422           GST_DEBUG_OBJECT (pad, "asked to drop item");
1423           break;
1424         case GST_PAD_PROBE_PASS:
1425           GST_DEBUG_OBJECT (pad, "asked to pass item");
1426           break;
1427         case GST_PAD_PROBE_OK:
1428           GST_DEBUG_OBJECT (pad, "probe returned OK");
1429           break;
1430         case GST_PAD_PROBE_HANDLED:
1431           GST_DEBUG_OBJECT (pad, "probe handled the data");
1432           break;
1433         default:
1434           GST_DEBUG_OBJECT (pad, "probe returned %d", ret);
1435           break;
1436       }
1437       pad->priv->idle_running--;
1438       if (pad->priv->idle_running == 0) {
1439         GST_PAD_BLOCK_BROADCAST (pad);
1440       }
1441       GST_OBJECT_UNLOCK (pad);
1442
1443       gst_object_unref (pad);
1444     }
1445   } else {
1446     GST_OBJECT_UNLOCK (pad);
1447   }
1448   return res;
1449 }
1450
1451 /**
1452  * gst_pad_remove_probe:
1453  * @pad: the #GstPad with the probe
1454  * @id: the probe id to remove
1455  *
1456  * Remove the probe with @id from @pad.
1457  *
1458  * MT safe.
1459  */
1460 void
1461 gst_pad_remove_probe (GstPad * pad, gulong id)
1462 {
1463   GHook *hook;
1464
1465   g_return_if_fail (GST_IS_PAD (pad));
1466
1467   GST_OBJECT_LOCK (pad);
1468
1469   hook = g_hook_get (&pad->probes, id);
1470   if (hook == NULL)
1471     goto not_found;
1472
1473   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "removing hook %ld",
1474       hook->hook_id);
1475   cleanup_hook (pad, hook);
1476   GST_OBJECT_UNLOCK (pad);
1477
1478   return;
1479
1480 not_found:
1481   {
1482     GST_OBJECT_UNLOCK (pad);
1483     g_warning ("%s: pad `%p' has no probe with id `%lu'", G_STRLOC, pad, id);
1484     return;
1485   }
1486 }
1487
1488 /**
1489  * gst_pad_is_blocked:
1490  * @pad: the #GstPad to query
1491  *
1492  * Checks if the pad is blocked or not. This function returns the
1493  * last requested state of the pad. It is not certain that the pad
1494  * is actually blocking at this point (see gst_pad_is_blocking()).
1495  *
1496  * Returns: %TRUE if the pad is blocked.
1497  *
1498  * MT safe.
1499  */
1500 gboolean
1501 gst_pad_is_blocked (GstPad * pad)
1502 {
1503   gboolean result = FALSE;
1504
1505   g_return_val_if_fail (GST_IS_PAD (pad), result);
1506
1507   GST_OBJECT_LOCK (pad);
1508   result = GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_BLOCKED);
1509   GST_OBJECT_UNLOCK (pad);
1510
1511   return result;
1512 }
1513
1514 /**
1515  * gst_pad_is_blocking:
1516  * @pad: the #GstPad to query
1517  *
1518  * Checks if the pad is blocking or not. This is a guaranteed state
1519  * of whether the pad is actually blocking on a #GstBuffer or a #GstEvent.
1520  *
1521  * Returns: %TRUE if the pad is blocking.
1522  *
1523  * MT safe.
1524  */
1525 gboolean
1526 gst_pad_is_blocking (GstPad * pad)
1527 {
1528   gboolean result = FALSE;
1529
1530   g_return_val_if_fail (GST_IS_PAD (pad), result);
1531
1532   GST_OBJECT_LOCK (pad);
1533   /* the blocking flag is only valid if the pad is not flushing */
1534   result = GST_PAD_IS_BLOCKING (pad) && !GST_PAD_IS_FLUSHING (pad);
1535   GST_OBJECT_UNLOCK (pad);
1536
1537   return result;
1538 }
1539
1540 /**
1541  * gst_pad_needs_reconfigure:
1542  * @pad: the #GstPad to check
1543  *
1544  * Check the #GST_PAD_FLAG_NEED_RECONFIGURE flag on @pad and return %TRUE
1545  * if the flag was set.
1546  *
1547  * Returns: %TRUE is the GST_PAD_FLAG_NEED_RECONFIGURE flag is set on @pad.
1548  */
1549 gboolean
1550 gst_pad_needs_reconfigure (GstPad * pad)
1551 {
1552   gboolean reconfigure;
1553
1554   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1555
1556   GST_OBJECT_LOCK (pad);
1557   reconfigure = GST_PAD_NEEDS_RECONFIGURE (pad);
1558   GST_DEBUG_OBJECT (pad, "peeking RECONFIGURE flag %d", reconfigure);
1559   GST_OBJECT_UNLOCK (pad);
1560
1561   return reconfigure;
1562 }
1563
1564 /**
1565  * gst_pad_check_reconfigure:
1566  * @pad: the #GstPad to check
1567  *
1568  * Check and clear the #GST_PAD_FLAG_NEED_RECONFIGURE flag on @pad and return %TRUE
1569  * if the flag was set.
1570  *
1571  * Returns: %TRUE is the GST_PAD_FLAG_NEED_RECONFIGURE flag was set on @pad.
1572  */
1573 gboolean
1574 gst_pad_check_reconfigure (GstPad * pad)
1575 {
1576   gboolean reconfigure;
1577
1578   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
1579
1580   GST_OBJECT_LOCK (pad);
1581   reconfigure = GST_PAD_NEEDS_RECONFIGURE (pad);
1582   if (reconfigure) {
1583     GST_DEBUG_OBJECT (pad, "remove RECONFIGURE flag");
1584     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
1585   }
1586   GST_OBJECT_UNLOCK (pad);
1587
1588   return reconfigure;
1589 }
1590
1591 /**
1592  * gst_pad_mark_reconfigure:
1593  * @pad: the #GstPad to mark
1594  *
1595  * Mark a pad for needing reconfiguration. The next call to
1596  * gst_pad_check_reconfigure() will return %TRUE after this call.
1597  */
1598 void
1599 gst_pad_mark_reconfigure (GstPad * pad)
1600 {
1601   g_return_if_fail (GST_IS_PAD (pad));
1602
1603   GST_OBJECT_LOCK (pad);
1604   GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
1605   GST_OBJECT_UNLOCK (pad);
1606 }
1607
1608 /**
1609  * gst_pad_set_activate_function:
1610  * @p: a #GstPad.
1611  * @f: the #GstPadActivateFunction to set.
1612  *
1613  * Calls gst_pad_set_activate_function_full() with %NULL for the user_data and
1614  * notify.
1615  */
1616 /**
1617  * gst_pad_set_activate_function_full:
1618  * @pad: a #GstPad.
1619  * @activate: the #GstPadActivateFunction to set.
1620  * @user_data: user_data passed to @notify
1621  * @notify: notify called when @activate will not be used anymore.
1622  *
1623  * Sets the given activate function for @pad. The activate function will
1624  * dispatch to gst_pad_activate_mode() to perform the actual activation.
1625  * Only makes sense to set on sink pads.
1626  *
1627  * Call this function if your sink pad can start a pull-based task.
1628  */
1629 void
1630 gst_pad_set_activate_function_full (GstPad * pad,
1631     GstPadActivateFunction activate, gpointer user_data, GDestroyNotify notify)
1632 {
1633   g_return_if_fail (GST_IS_PAD (pad));
1634
1635   if (pad->activatenotify)
1636     pad->activatenotify (pad->activatedata);
1637   GST_PAD_ACTIVATEFUNC (pad) = activate;
1638   pad->activatedata = user_data;
1639   pad->activatenotify = notify;
1640
1641   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "activatefunc set to %s",
1642       GST_DEBUG_FUNCPTR_NAME (activate));
1643 }
1644
1645 /**
1646  * gst_pad_set_activatemode_function:
1647  * @p: a #GstPad.
1648  * @f: the #GstPadActivateModeFunction to set.
1649  *
1650  * Calls gst_pad_set_activatemode_function_full() with %NULL for the user_data and
1651  * notify.
1652  */
1653 /**
1654  * gst_pad_set_activatemode_function_full:
1655  * @pad: a #GstPad.
1656  * @activatemode: the #GstPadActivateModeFunction to set.
1657  * @user_data: user_data passed to @notify
1658  * @notify: notify called when @activatemode will not be used anymore.
1659  *
1660  * Sets the given activate_mode function for the pad. An activate_mode function
1661  * prepares the element for data passing.
1662  */
1663 void
1664 gst_pad_set_activatemode_function_full (GstPad * pad,
1665     GstPadActivateModeFunction activatemode, gpointer user_data,
1666     GDestroyNotify notify)
1667 {
1668   g_return_if_fail (GST_IS_PAD (pad));
1669
1670   if (pad->activatemodenotify)
1671     pad->activatemodenotify (pad->activatemodedata);
1672   GST_PAD_ACTIVATEMODEFUNC (pad) = activatemode;
1673   pad->activatemodedata = user_data;
1674   pad->activatemodenotify = notify;
1675
1676   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "activatemodefunc set to %s",
1677       GST_DEBUG_FUNCPTR_NAME (activatemode));
1678 }
1679
1680 /**
1681  * gst_pad_set_chain_function:
1682  * @p: a sink #GstPad.
1683  * @f: the #GstPadChainFunction to set.
1684  *
1685  * Calls gst_pad_set_chain_function_full() with %NULL for the user_data and
1686  * notify.
1687  */
1688 /**
1689  * gst_pad_set_chain_function_full:
1690  * @pad: a sink #GstPad.
1691  * @chain: the #GstPadChainFunction to set.
1692  * @user_data: user_data passed to @notify
1693  * @notify: notify called when @chain will not be used anymore.
1694  *
1695  * Sets the given chain function for the pad. The chain function is called to
1696  * process a #GstBuffer input buffer. see #GstPadChainFunction for more details.
1697  */
1698 void
1699 gst_pad_set_chain_function_full (GstPad * pad, GstPadChainFunction chain,
1700     gpointer user_data, GDestroyNotify notify)
1701 {
1702   g_return_if_fail (GST_IS_PAD (pad));
1703   g_return_if_fail (GST_PAD_IS_SINK (pad));
1704
1705   if (pad->chainnotify)
1706     pad->chainnotify (pad->chaindata);
1707   GST_PAD_CHAINFUNC (pad) = chain;
1708   pad->chaindata = user_data;
1709   pad->chainnotify = notify;
1710
1711   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "chainfunc set to %s",
1712       GST_DEBUG_FUNCPTR_NAME (chain));
1713 }
1714
1715 /**
1716  * gst_pad_set_chain_list_function:
1717  * @p: a sink #GstPad.
1718  * @f: the #GstPadChainListFunction to set.
1719  *
1720  * Calls gst_pad_set_chain_list_function_full() with %NULL for the user_data and
1721  * notify.
1722  */
1723 /**
1724  * gst_pad_set_chain_list_function_full:
1725  * @pad: a sink #GstPad.
1726  * @chainlist: the #GstPadChainListFunction to set.
1727  * @user_data: user_data passed to @notify
1728  * @notify: notify called when @chainlist will not be used anymore.
1729  *
1730  * Sets the given chain list function for the pad. The chainlist function is
1731  * called to process a #GstBufferList input buffer list. See
1732  * #GstPadChainListFunction for more details.
1733  */
1734 void
1735 gst_pad_set_chain_list_function_full (GstPad * pad,
1736     GstPadChainListFunction chainlist, gpointer user_data,
1737     GDestroyNotify notify)
1738 {
1739   g_return_if_fail (GST_IS_PAD (pad));
1740   g_return_if_fail (GST_PAD_IS_SINK (pad));
1741
1742   if (pad->chainlistnotify)
1743     pad->chainlistnotify (pad->chainlistdata);
1744   GST_PAD_CHAINLISTFUNC (pad) = chainlist;
1745   pad->chainlistdata = user_data;
1746   pad->chainlistnotify = notify;
1747
1748   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "chainlistfunc set to %s",
1749       GST_DEBUG_FUNCPTR_NAME (chainlist));
1750 }
1751
1752 /**
1753  * gst_pad_set_getrange_function:
1754  * @p: a source #GstPad.
1755  * @f: the #GstPadGetRangeFunction to set.
1756  *
1757  * Calls gst_pad_set_getrange_function_full() with %NULL for the user_data and
1758  * notify.
1759  */
1760 /**
1761  * gst_pad_set_getrange_function_full:
1762  * @pad: a source #GstPad.
1763  * @get: the #GstPadGetRangeFunction to set.
1764  * @user_data: user_data passed to @notify
1765  * @notify: notify called when @get will not be used anymore.
1766  *
1767  * Sets the given getrange function for the pad. The getrange function is
1768  * called to produce a new #GstBuffer to start the processing pipeline. see
1769  * #GstPadGetRangeFunction for a description of the getrange function.
1770  */
1771 void
1772 gst_pad_set_getrange_function_full (GstPad * pad, GstPadGetRangeFunction get,
1773     gpointer user_data, GDestroyNotify notify)
1774 {
1775   g_return_if_fail (GST_IS_PAD (pad));
1776   g_return_if_fail (GST_PAD_IS_SRC (pad));
1777
1778   if (pad->getrangenotify)
1779     pad->getrangenotify (pad->getrangedata);
1780   GST_PAD_GETRANGEFUNC (pad) = get;
1781   pad->getrangedata = user_data;
1782   pad->getrangenotify = notify;
1783
1784   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "getrangefunc set to %s",
1785       GST_DEBUG_FUNCPTR_NAME (get));
1786 }
1787
1788 /**
1789  * gst_pad_set_event_function:
1790  * @p: a #GstPad of either direction.
1791  * @f: the #GstPadEventFunction to set.
1792  *
1793  * Calls gst_pad_set_event_function_full() with %NULL for the user_data and
1794  * notify.
1795  */
1796 /**
1797  * gst_pad_set_event_function_full:
1798  * @pad: a #GstPad of either direction.
1799  * @event: the #GstPadEventFunction to set.
1800  * @user_data: user_data passed to @notify
1801  * @notify: notify called when @event will not be used anymore.
1802  *
1803  * Sets the given event handler for the pad.
1804  */
1805 void
1806 gst_pad_set_event_function_full (GstPad * pad, GstPadEventFunction event,
1807     gpointer user_data, GDestroyNotify notify)
1808 {
1809   g_return_if_fail (GST_IS_PAD (pad));
1810
1811   if (pad->eventnotify)
1812     pad->eventnotify (pad->eventdata);
1813   GST_PAD_EVENTFUNC (pad) = event;
1814   pad->eventdata = user_data;
1815   pad->eventnotify = notify;
1816
1817   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "eventfunc for set to %s",
1818       GST_DEBUG_FUNCPTR_NAME (event));
1819 }
1820
1821 /**
1822  * gst_pad_set_query_function:
1823  * @p: a #GstPad of either direction.
1824  * @f: the #GstPadQueryFunction to set.
1825  *
1826  * Calls gst_pad_set_query_function_full() with %NULL for the user_data and
1827  * notify.
1828  */
1829 /**
1830  * gst_pad_set_query_function_full:
1831  * @pad: a #GstPad of either direction.
1832  * @query: the #GstPadQueryFunction to set.
1833  * @user_data: user_data passed to @notify
1834  * @notify: notify called when @query will not be used anymore.
1835  *
1836  * Set the given query function for the pad.
1837  */
1838 void
1839 gst_pad_set_query_function_full (GstPad * pad, GstPadQueryFunction query,
1840     gpointer user_data, GDestroyNotify notify)
1841 {
1842   g_return_if_fail (GST_IS_PAD (pad));
1843
1844   if (pad->querynotify)
1845     pad->querynotify (pad->querydata);
1846   GST_PAD_QUERYFUNC (pad) = query;
1847   pad->querydata = user_data;
1848   pad->querynotify = notify;
1849
1850   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "queryfunc set to %s",
1851       GST_DEBUG_FUNCPTR_NAME (query));
1852 }
1853
1854 /**
1855  * gst_pad_set_iterate_internal_links_function:
1856  * @p: a #GstPad of either direction.
1857  * @f: the #GstPadIterIntLinkFunction to set.
1858  *
1859  * Calls gst_pad_set_iterate_internal_links_function_full() with %NULL
1860  * for the user_data and notify.
1861  */
1862 /**
1863  * gst_pad_set_iterate_internal_links_function_full:
1864  * @pad: a #GstPad of either direction.
1865  * @iterintlink: the #GstPadIterIntLinkFunction to set.
1866  * @user_data: user_data passed to @notify
1867  * @notify: notify called when @iterintlink will not be used anymore.
1868  *
1869  * Sets the given internal link iterator function for the pad.
1870  */
1871 void
1872 gst_pad_set_iterate_internal_links_function_full (GstPad * pad,
1873     GstPadIterIntLinkFunction iterintlink, gpointer user_data,
1874     GDestroyNotify notify)
1875 {
1876   g_return_if_fail (GST_IS_PAD (pad));
1877
1878   if (pad->iterintlinknotify)
1879     pad->iterintlinknotify (pad->iterintlinkdata);
1880   GST_PAD_ITERINTLINKFUNC (pad) = iterintlink;
1881   pad->iterintlinkdata = user_data;
1882   pad->iterintlinknotify = notify;
1883
1884   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "internal link iterator set to %s",
1885       GST_DEBUG_FUNCPTR_NAME (iterintlink));
1886 }
1887
1888 /**
1889  * gst_pad_set_link_function:
1890  * @p: a #GstPad.
1891  * @f: the #GstPadLinkFunction to set.
1892  *
1893  * Calls gst_pad_set_link_function_full() with %NULL
1894  * for the user_data and notify.
1895  */
1896 /**
1897  * gst_pad_set_link_function_full:
1898  * @pad: a #GstPad.
1899  * @link: the #GstPadLinkFunction to set.
1900  * @user_data: user_data passed to @notify
1901  * @notify: notify called when @link will not be used anymore.
1902  *
1903  * Sets the given link function for the pad. It will be called when
1904  * the pad is linked with another pad.
1905  *
1906  * The return value #GST_PAD_LINK_OK should be used when the connection can be
1907  * made.
1908  *
1909  * The return value #GST_PAD_LINK_REFUSED should be used when the connection
1910  * cannot be made for some reason.
1911  *
1912  * If @link is installed on a source pad, it should call the #GstPadLinkFunction
1913  * of the peer sink pad, if present.
1914  */
1915 void
1916 gst_pad_set_link_function_full (GstPad * pad, GstPadLinkFunction link,
1917     gpointer user_data, GDestroyNotify notify)
1918 {
1919   g_return_if_fail (GST_IS_PAD (pad));
1920
1921   if (pad->linknotify)
1922     pad->linknotify (pad->linkdata);
1923   GST_PAD_LINKFUNC (pad) = link;
1924   pad->linkdata = user_data;
1925   pad->linknotify = notify;
1926
1927   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "linkfunc set to %s",
1928       GST_DEBUG_FUNCPTR_NAME (link));
1929 }
1930
1931 /**
1932  * gst_pad_set_unlink_function:
1933  * @p: a #GstPad.
1934  * @f: the #GstPadUnlinkFunction to set.
1935  *
1936  * Calls gst_pad_set_unlink_function_full() with %NULL
1937  * for the user_data and notify.
1938  */
1939 /**
1940  * gst_pad_set_unlink_function_full:
1941  * @pad: a #GstPad.
1942  * @unlink: the #GstPadUnlinkFunction to set.
1943  * @user_data: user_data passed to @notify
1944  * @notify: notify called when @unlink will not be used anymore.
1945  *
1946  * Sets the given unlink function for the pad. It will be called
1947  * when the pad is unlinked.
1948  */
1949 void
1950 gst_pad_set_unlink_function_full (GstPad * pad, GstPadUnlinkFunction unlink,
1951     gpointer user_data, GDestroyNotify notify)
1952 {
1953   g_return_if_fail (GST_IS_PAD (pad));
1954
1955   if (pad->unlinknotify)
1956     pad->unlinknotify (pad->unlinkdata);
1957   GST_PAD_UNLINKFUNC (pad) = unlink;
1958   pad->unlinkdata = user_data;
1959   pad->unlinknotify = notify;
1960
1961   GST_CAT_DEBUG_OBJECT (GST_CAT_PADS, pad, "unlinkfunc set to %s",
1962       GST_DEBUG_FUNCPTR_NAME (unlink));
1963 }
1964
1965 /**
1966  * gst_pad_unlink:
1967  * @srcpad: the source #GstPad to unlink.
1968  * @sinkpad: the sink #GstPad to unlink.
1969  *
1970  * Unlinks the source pad from the sink pad. Will emit the #GstPad::unlinked
1971  * signal on both pads.
1972  *
1973  * Returns: %TRUE if the pads were unlinked. This function returns %FALSE if
1974  * the pads were not linked together.
1975  *
1976  * MT safe.
1977  */
1978 gboolean
1979 gst_pad_unlink (GstPad * srcpad, GstPad * sinkpad)
1980 {
1981   gboolean result = FALSE;
1982   GstElement *parent = NULL;
1983
1984   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
1985   g_return_val_if_fail (GST_PAD_IS_SRC (srcpad), FALSE);
1986   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
1987   g_return_val_if_fail (GST_PAD_IS_SINK (sinkpad), FALSE);
1988
1989   GST_CAT_INFO (GST_CAT_ELEMENT_PADS, "unlinking %s:%s(%p) and %s:%s(%p)",
1990       GST_DEBUG_PAD_NAME (srcpad), srcpad,
1991       GST_DEBUG_PAD_NAME (sinkpad), sinkpad);
1992
1993   /* We need to notify the parent before taking any pad locks as the bin in
1994    * question might be waiting for a lock on the pad while holding its lock
1995    * that our message will try to take. */
1996   if ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (srcpad)))) {
1997     if (GST_IS_ELEMENT (parent)) {
1998       gst_element_post_message (parent,
1999           gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2000               GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK, parent, TRUE));
2001     } else {
2002       gst_object_unref (parent);
2003       parent = NULL;
2004     }
2005   }
2006
2007   GST_OBJECT_LOCK (srcpad);
2008   GST_OBJECT_LOCK (sinkpad);
2009
2010   if (G_UNLIKELY (GST_PAD_PEER (srcpad) != sinkpad))
2011     goto not_linked_together;
2012
2013   if (GST_PAD_UNLINKFUNC (srcpad)) {
2014     GstObject *tmpparent;
2015
2016     ACQUIRE_PARENT (srcpad, tmpparent, no_src_parent);
2017
2018     GST_PAD_UNLINKFUNC (srcpad) (srcpad, tmpparent);
2019     RELEASE_PARENT (tmpparent);
2020   }
2021 no_src_parent:
2022   if (GST_PAD_UNLINKFUNC (sinkpad)) {
2023     GstObject *tmpparent;
2024
2025     ACQUIRE_PARENT (sinkpad, tmpparent, no_sink_parent);
2026
2027     GST_PAD_UNLINKFUNC (sinkpad) (sinkpad, tmpparent);
2028     RELEASE_PARENT (tmpparent);
2029   }
2030 no_sink_parent:
2031
2032   /* first clear peers */
2033   GST_PAD_PEER (srcpad) = NULL;
2034   GST_PAD_PEER (sinkpad) = NULL;
2035
2036   GST_OBJECT_UNLOCK (sinkpad);
2037   GST_OBJECT_UNLOCK (srcpad);
2038
2039   /* fire off a signal to each of the pads telling them
2040    * that they've been unlinked */
2041   g_signal_emit (srcpad, gst_pad_signals[PAD_UNLINKED], 0, sinkpad);
2042   g_signal_emit (sinkpad, gst_pad_signals[PAD_UNLINKED], 0, srcpad);
2043
2044   GST_CAT_INFO (GST_CAT_ELEMENT_PADS, "unlinked %s:%s and %s:%s",
2045       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2046
2047   result = TRUE;
2048
2049 done:
2050   if (parent != NULL) {
2051     gst_element_post_message (parent,
2052         gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2053             GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK, parent, FALSE));
2054     gst_object_unref (parent);
2055   }
2056   return result;
2057
2058   /* ERRORS */
2059 not_linked_together:
2060   {
2061     /* we do not emit a warning in this case because unlinking cannot
2062      * be made MT safe.*/
2063     GST_OBJECT_UNLOCK (sinkpad);
2064     GST_OBJECT_UNLOCK (srcpad);
2065     goto done;
2066   }
2067 }
2068
2069 /**
2070  * gst_pad_is_linked:
2071  * @pad: pad to check
2072  *
2073  * Checks if a @pad is linked to another pad or not.
2074  *
2075  * Returns: %TRUE if the pad is linked, %FALSE otherwise.
2076  *
2077  * MT safe.
2078  */
2079 gboolean
2080 gst_pad_is_linked (GstPad * pad)
2081 {
2082   gboolean result;
2083
2084   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2085
2086   GST_OBJECT_LOCK (pad);
2087   result = (GST_PAD_PEER (pad) != NULL);
2088   GST_OBJECT_UNLOCK (pad);
2089
2090   return result;
2091 }
2092
2093 /* get the caps from both pads and see if the intersection
2094  * is not empty.
2095  *
2096  * This function should be called with the pad LOCK on both
2097  * pads
2098  */
2099 static gboolean
2100 gst_pad_link_check_compatible_unlocked (GstPad * src, GstPad * sink,
2101     GstPadLinkCheck flags)
2102 {
2103   GstCaps *srccaps = NULL;
2104   GstCaps *sinkcaps = NULL;
2105   gboolean compatible = FALSE;
2106
2107   if (!(flags & (GST_PAD_LINK_CHECK_CAPS | GST_PAD_LINK_CHECK_TEMPLATE_CAPS)))
2108     return TRUE;
2109
2110   /* Doing the expensive caps checking takes priority over only checking the template caps */
2111   if (flags & GST_PAD_LINK_CHECK_CAPS) {
2112     GST_OBJECT_UNLOCK (sink);
2113     GST_OBJECT_UNLOCK (src);
2114
2115     srccaps = gst_pad_query_caps (src, NULL);
2116     sinkcaps = gst_pad_query_caps (sink, NULL);
2117
2118     GST_OBJECT_LOCK (src);
2119     GST_OBJECT_LOCK (sink);
2120   } else {
2121     /* If one of the two pads doesn't have a template, consider the intersection
2122      * as valid.*/
2123     if (G_UNLIKELY ((GST_PAD_PAD_TEMPLATE (src) == NULL)
2124             || (GST_PAD_PAD_TEMPLATE (sink) == NULL))) {
2125       compatible = TRUE;
2126       goto done;
2127     }
2128     srccaps = gst_caps_ref (GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (src)));
2129     sinkcaps =
2130         gst_caps_ref (GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (sink)));
2131   }
2132
2133   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, src, "src caps %" GST_PTR_FORMAT,
2134       srccaps);
2135   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, sink, "sink caps %" GST_PTR_FORMAT,
2136       sinkcaps);
2137
2138   /* if we have caps on both pads we can check the intersection. If one
2139    * of the caps is %NULL, we return %TRUE. */
2140   if (G_UNLIKELY (srccaps == NULL || sinkcaps == NULL)) {
2141     if (srccaps)
2142       gst_caps_unref (srccaps);
2143     if (sinkcaps)
2144       gst_caps_unref (sinkcaps);
2145     goto done;
2146   }
2147
2148   compatible = gst_caps_can_intersect (srccaps, sinkcaps);
2149   gst_caps_unref (srccaps);
2150   gst_caps_unref (sinkcaps);
2151
2152 done:
2153   GST_CAT_DEBUG (GST_CAT_CAPS, "caps are %scompatible",
2154       (compatible ? "" : "not "));
2155
2156   return compatible;
2157 }
2158
2159 /* check if the grandparents of both pads are the same.
2160  * This check is required so that we don't try to link
2161  * pads from elements in different bins without ghostpads.
2162  *
2163  * The LOCK should be held on both pads
2164  */
2165 static gboolean
2166 gst_pad_link_check_hierarchy (GstPad * src, GstPad * sink)
2167 {
2168   GstObject *psrc, *psink;
2169
2170   psrc = GST_OBJECT_PARENT (src);
2171   psink = GST_OBJECT_PARENT (sink);
2172
2173   /* if one of the pads has no parent, we allow the link */
2174   if (G_UNLIKELY (psrc == NULL || psink == NULL))
2175     goto no_parent;
2176
2177   /* only care about parents that are elements */
2178   if (G_UNLIKELY (!GST_IS_ELEMENT (psrc) || !GST_IS_ELEMENT (psink)))
2179     goto no_element_parent;
2180
2181   /* if the parents are the same, we have a loop */
2182   if (G_UNLIKELY (psrc == psink))
2183     goto same_parents;
2184
2185   /* if they both have a parent, we check the grandparents. We can not lock
2186    * the parent because we hold on the child (pad) and the locking order is
2187    * parent >> child. */
2188   psrc = GST_OBJECT_PARENT (psrc);
2189   psink = GST_OBJECT_PARENT (psink);
2190
2191   /* if they have grandparents but they are not the same */
2192   if (G_UNLIKELY (psrc != psink))
2193     goto wrong_grandparents;
2194
2195   return TRUE;
2196
2197   /* ERRORS */
2198 no_parent:
2199   {
2200     GST_CAT_DEBUG (GST_CAT_CAPS,
2201         "one of the pads has no parent %" GST_PTR_FORMAT " and %"
2202         GST_PTR_FORMAT, psrc, psink);
2203     return TRUE;
2204   }
2205 no_element_parent:
2206   {
2207     GST_CAT_DEBUG (GST_CAT_CAPS,
2208         "one of the pads has no element parent %" GST_PTR_FORMAT " and %"
2209         GST_PTR_FORMAT, psrc, psink);
2210     return TRUE;
2211   }
2212 same_parents:
2213   {
2214     GST_CAT_DEBUG (GST_CAT_CAPS, "pads have same parent %" GST_PTR_FORMAT,
2215         psrc);
2216     return FALSE;
2217   }
2218 wrong_grandparents:
2219   {
2220     GST_CAT_DEBUG (GST_CAT_CAPS,
2221         "pads have different grandparents %" GST_PTR_FORMAT " and %"
2222         GST_PTR_FORMAT, psrc, psink);
2223     return FALSE;
2224   }
2225 }
2226
2227 /* FIXME leftover from an attempt at refactoring... */
2228 /* call with the two pads unlocked, when this function returns GST_PAD_LINK_OK,
2229  * the two pads will be locked in the srcpad, sinkpad order. */
2230 static GstPadLinkReturn
2231 gst_pad_link_prepare (GstPad * srcpad, GstPad * sinkpad, GstPadLinkCheck flags)
2232 {
2233   GST_CAT_INFO (GST_CAT_PADS, "trying to link %s:%s and %s:%s",
2234       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2235
2236   GST_OBJECT_LOCK (srcpad);
2237
2238   if (G_UNLIKELY (GST_PAD_PEER (srcpad) != NULL))
2239     goto src_was_linked;
2240
2241   GST_OBJECT_LOCK (sinkpad);
2242
2243   if (G_UNLIKELY (GST_PAD_PEER (sinkpad) != NULL))
2244     goto sink_was_linked;
2245
2246   /* check hierarchy, pads can only be linked if the grandparents
2247    * are the same. */
2248   if ((flags & GST_PAD_LINK_CHECK_HIERARCHY)
2249       && !gst_pad_link_check_hierarchy (srcpad, sinkpad))
2250     goto wrong_hierarchy;
2251
2252   /* check pad caps for non-empty intersection */
2253   if (!gst_pad_link_check_compatible_unlocked (srcpad, sinkpad, flags))
2254     goto no_format;
2255
2256   /* FIXME check pad scheduling for non-empty intersection */
2257
2258   return GST_PAD_LINK_OK;
2259
2260 src_was_linked:
2261   {
2262     GST_CAT_INFO (GST_CAT_PADS, "src %s:%s was already linked to %s:%s",
2263         GST_DEBUG_PAD_NAME (srcpad),
2264         GST_DEBUG_PAD_NAME (GST_PAD_PEER (srcpad)));
2265     /* we do not emit a warning in this case because unlinking cannot
2266      * be made MT safe.*/
2267     GST_OBJECT_UNLOCK (srcpad);
2268     return GST_PAD_LINK_WAS_LINKED;
2269   }
2270 sink_was_linked:
2271   {
2272     GST_CAT_INFO (GST_CAT_PADS, "sink %s:%s was already linked to %s:%s",
2273         GST_DEBUG_PAD_NAME (sinkpad),
2274         GST_DEBUG_PAD_NAME (GST_PAD_PEER (sinkpad)));
2275     /* we do not emit a warning in this case because unlinking cannot
2276      * be made MT safe.*/
2277     GST_OBJECT_UNLOCK (sinkpad);
2278     GST_OBJECT_UNLOCK (srcpad);
2279     return GST_PAD_LINK_WAS_LINKED;
2280   }
2281 wrong_hierarchy:
2282   {
2283     GST_CAT_INFO (GST_CAT_PADS, "pads have wrong hierarchy");
2284     GST_OBJECT_UNLOCK (sinkpad);
2285     GST_OBJECT_UNLOCK (srcpad);
2286     return GST_PAD_LINK_WRONG_HIERARCHY;
2287   }
2288 no_format:
2289   {
2290     GST_CAT_INFO (GST_CAT_PADS, "caps are incompatible");
2291     GST_OBJECT_UNLOCK (sinkpad);
2292     GST_OBJECT_UNLOCK (srcpad);
2293     return GST_PAD_LINK_NOFORMAT;
2294   }
2295 }
2296
2297 /**
2298  * gst_pad_can_link:
2299  * @srcpad: the source #GstPad.
2300  * @sinkpad: the sink #GstPad.
2301  *
2302  * Checks if the source pad and the sink pad are compatible so they can be
2303  * linked.
2304  *
2305  * Returns: %TRUE if the pads can be linked.
2306  */
2307 gboolean
2308 gst_pad_can_link (GstPad * srcpad, GstPad * sinkpad)
2309 {
2310   GstPadLinkReturn result;
2311
2312   /* generic checks */
2313   g_return_val_if_fail (GST_IS_PAD (srcpad), FALSE);
2314   g_return_val_if_fail (GST_IS_PAD (sinkpad), FALSE);
2315
2316   GST_CAT_INFO (GST_CAT_PADS, "check if %s:%s can link with %s:%s",
2317       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2318
2319   /* gst_pad_link_prepare does everything for us, we only release the locks
2320    * on the pads that it gets us. If this function returns !OK the locks are not
2321    * taken anymore. */
2322   result = gst_pad_link_prepare (srcpad, sinkpad, GST_PAD_LINK_CHECK_DEFAULT);
2323   if (result != GST_PAD_LINK_OK)
2324     goto done;
2325
2326   GST_OBJECT_UNLOCK (srcpad);
2327   GST_OBJECT_UNLOCK (sinkpad);
2328
2329 done:
2330   return result == GST_PAD_LINK_OK;
2331 }
2332
2333 /**
2334  * gst_pad_link_full:
2335  * @srcpad: the source #GstPad to link.
2336  * @sinkpad: the sink #GstPad to link.
2337  * @flags: the checks to validate when linking
2338  *
2339  * Links the source pad and the sink pad.
2340  *
2341  * This variant of #gst_pad_link provides a more granular control on the
2342  * checks being done when linking. While providing some considerable speedups
2343  * the caller of this method must be aware that wrong usage of those flags
2344  * can cause severe issues. Refer to the documentation of #GstPadLinkCheck
2345  * for more information.
2346  *
2347  * MT Safe.
2348  *
2349  * Returns: A result code indicating if the connection worked or
2350  *          what went wrong.
2351  */
2352 GstPadLinkReturn
2353 gst_pad_link_full (GstPad * srcpad, GstPad * sinkpad, GstPadLinkCheck flags)
2354 {
2355   GstPadLinkReturn result;
2356   GstElement *parent;
2357   GstPadLinkFunction srcfunc, sinkfunc;
2358
2359   g_return_val_if_fail (GST_IS_PAD (srcpad), GST_PAD_LINK_REFUSED);
2360   g_return_val_if_fail (GST_PAD_IS_SRC (srcpad), GST_PAD_LINK_WRONG_DIRECTION);
2361   g_return_val_if_fail (GST_IS_PAD (sinkpad), GST_PAD_LINK_REFUSED);
2362   g_return_val_if_fail (GST_PAD_IS_SINK (sinkpad),
2363       GST_PAD_LINK_WRONG_DIRECTION);
2364
2365   /* Notify the parent early. See gst_pad_unlink for details. */
2366   if (G_LIKELY ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (srcpad))))) {
2367     if (G_LIKELY (GST_IS_ELEMENT (parent))) {
2368       gst_element_post_message (parent,
2369           gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2370               GST_STRUCTURE_CHANGE_TYPE_PAD_LINK, parent, TRUE));
2371     } else {
2372       gst_object_unref (parent);
2373       parent = NULL;
2374     }
2375   }
2376
2377   /* prepare will also lock the two pads */
2378   result = gst_pad_link_prepare (srcpad, sinkpad, flags);
2379
2380   if (G_UNLIKELY (result != GST_PAD_LINK_OK)) {
2381     GST_CAT_INFO (GST_CAT_PADS, "link between %s:%s and %s:%s failed: %s",
2382         GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad),
2383         gst_pad_link_get_name (result));
2384     goto done;
2385   }
2386
2387   /* must set peers before calling the link function */
2388   GST_PAD_PEER (srcpad) = sinkpad;
2389   GST_PAD_PEER (sinkpad) = srcpad;
2390
2391   /* check events, when something is different, mark pending */
2392   schedule_events (srcpad, sinkpad);
2393
2394   /* get the link functions */
2395   srcfunc = GST_PAD_LINKFUNC (srcpad);
2396   sinkfunc = GST_PAD_LINKFUNC (sinkpad);
2397
2398   if (G_UNLIKELY (srcfunc || sinkfunc)) {
2399     /* custom link functions, execute them */
2400     GST_OBJECT_UNLOCK (sinkpad);
2401     GST_OBJECT_UNLOCK (srcpad);
2402
2403     if (srcfunc) {
2404       GstObject *tmpparent;
2405
2406       ACQUIRE_PARENT (srcpad, tmpparent, no_parent);
2407       /* this one will call the peer link function */
2408       result = srcfunc (srcpad, tmpparent, sinkpad);
2409       RELEASE_PARENT (tmpparent);
2410     } else if (sinkfunc) {
2411       GstObject *tmpparent;
2412
2413       ACQUIRE_PARENT (sinkpad, tmpparent, no_parent);
2414       /* if no source link function, we need to call the sink link
2415        * function ourselves. */
2416       result = sinkfunc (sinkpad, tmpparent, srcpad);
2417       RELEASE_PARENT (tmpparent);
2418     }
2419   no_parent:
2420
2421     GST_OBJECT_LOCK (srcpad);
2422     GST_OBJECT_LOCK (sinkpad);
2423
2424     /* we released the lock, check if the same pads are linked still */
2425     if (GST_PAD_PEER (srcpad) != sinkpad || GST_PAD_PEER (sinkpad) != srcpad)
2426       goto concurrent_link;
2427
2428     if (G_UNLIKELY (result != GST_PAD_LINK_OK))
2429       goto link_failed;
2430   }
2431   GST_OBJECT_UNLOCK (sinkpad);
2432   GST_OBJECT_UNLOCK (srcpad);
2433
2434   /* fire off a signal to each of the pads telling them
2435    * that they've been linked */
2436   g_signal_emit (srcpad, gst_pad_signals[PAD_LINKED], 0, sinkpad);
2437   g_signal_emit (sinkpad, gst_pad_signals[PAD_LINKED], 0, srcpad);
2438
2439   GST_CAT_INFO (GST_CAT_PADS, "linked %s:%s and %s:%s, successful",
2440       GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2441
2442   gst_pad_send_event (srcpad, gst_event_new_reconfigure ());
2443
2444 done:
2445   if (G_LIKELY (parent)) {
2446     gst_element_post_message (parent,
2447         gst_message_new_structure_change (GST_OBJECT_CAST (sinkpad),
2448             GST_STRUCTURE_CHANGE_TYPE_PAD_LINK, parent, FALSE));
2449     gst_object_unref (parent);
2450   }
2451
2452   return result;
2453
2454   /* ERRORS */
2455 concurrent_link:
2456   {
2457     GST_CAT_INFO (GST_CAT_PADS, "concurrent link between %s:%s and %s:%s",
2458         GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
2459     GST_OBJECT_UNLOCK (sinkpad);
2460     GST_OBJECT_UNLOCK (srcpad);
2461
2462     /* The other link operation succeeded first */
2463     result = GST_PAD_LINK_WAS_LINKED;
2464     goto done;
2465   }
2466 link_failed:
2467   {
2468     GST_CAT_INFO (GST_CAT_PADS, "link between %s:%s and %s:%s failed: %s",
2469         GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad),
2470         gst_pad_link_get_name (result));
2471
2472     GST_PAD_PEER (srcpad) = NULL;
2473     GST_PAD_PEER (sinkpad) = NULL;
2474
2475     GST_OBJECT_UNLOCK (sinkpad);
2476     GST_OBJECT_UNLOCK (srcpad);
2477
2478     goto done;
2479   }
2480 }
2481
2482 /**
2483  * gst_pad_link:
2484  * @srcpad: the source #GstPad to link.
2485  * @sinkpad: the sink #GstPad to link.
2486  *
2487  * Links the source pad and the sink pad.
2488  *
2489  * Returns: A result code indicating if the connection worked or
2490  *          what went wrong.
2491  *
2492  * MT Safe.
2493  */
2494 GstPadLinkReturn
2495 gst_pad_link (GstPad * srcpad, GstPad * sinkpad)
2496 {
2497   return gst_pad_link_full (srcpad, sinkpad, GST_PAD_LINK_CHECK_DEFAULT);
2498 }
2499
2500 static void
2501 gst_pad_set_pad_template (GstPad * pad, GstPadTemplate * templ)
2502 {
2503   GstPadTemplate **template_p;
2504
2505   /* this function would need checks if it weren't static */
2506
2507   GST_OBJECT_LOCK (pad);
2508   template_p = &pad->padtemplate;
2509   gst_object_replace ((GstObject **) template_p, (GstObject *) templ);
2510   GST_OBJECT_UNLOCK (pad);
2511
2512   if (templ)
2513     gst_pad_template_pad_created (templ, pad);
2514 }
2515
2516 /**
2517  * gst_pad_get_pad_template:
2518  * @pad: a #GstPad.
2519  *
2520  * Gets the template for @pad.
2521  *
2522  * Returns: (transfer full) (nullable): the #GstPadTemplate from which
2523  *     this pad was instantiated, or %NULL if this pad has no
2524  *     template. Unref after usage.
2525  */
2526 GstPadTemplate *
2527 gst_pad_get_pad_template (GstPad * pad)
2528 {
2529   GstPadTemplate *templ;
2530
2531   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2532
2533   templ = GST_PAD_PAD_TEMPLATE (pad);
2534
2535   return (templ ? gst_object_ref (templ) : NULL);
2536 }
2537
2538 /**
2539  * gst_pad_has_current_caps:
2540  * @pad: a  #GstPad to check
2541  *
2542  * Check if @pad has caps set on it with a #GST_EVENT_CAPS event.
2543  *
2544  * Returns: %TRUE when @pad has caps associated with it.
2545  */
2546 gboolean
2547 gst_pad_has_current_caps (GstPad * pad)
2548 {
2549   gboolean result;
2550   GstCaps *caps;
2551
2552   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2553
2554   GST_OBJECT_LOCK (pad);
2555   caps = get_pad_caps (pad);
2556   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2557       "check current pad caps %" GST_PTR_FORMAT, caps);
2558   result = (caps != NULL);
2559   GST_OBJECT_UNLOCK (pad);
2560
2561   return result;
2562 }
2563
2564 /**
2565  * gst_pad_get_current_caps:
2566  * @pad: a  #GstPad to get the current capabilities of.
2567  *
2568  * Gets the capabilities currently configured on @pad with the last
2569  * #GST_EVENT_CAPS event.
2570  *
2571  * Returns: the current caps of the pad with incremented ref-count.
2572  */
2573 GstCaps *
2574 gst_pad_get_current_caps (GstPad * pad)
2575 {
2576   GstCaps *result;
2577
2578   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2579
2580   GST_OBJECT_LOCK (pad);
2581   if ((result = get_pad_caps (pad)))
2582     gst_caps_ref (result);
2583   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
2584       "get current pad caps %" GST_PTR_FORMAT, result);
2585   GST_OBJECT_UNLOCK (pad);
2586
2587   return result;
2588 }
2589
2590 /**
2591  * gst_pad_get_pad_template_caps:
2592  * @pad: a #GstPad to get the template capabilities from.
2593  *
2594  * Gets the capabilities for @pad's template.
2595  *
2596  * Returns: (transfer full): the #GstCaps of this pad template.
2597  * Unref after usage.
2598  */
2599 GstCaps *
2600 gst_pad_get_pad_template_caps (GstPad * pad)
2601 {
2602   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2603
2604   if (GST_PAD_PAD_TEMPLATE (pad))
2605     return gst_pad_template_get_caps (GST_PAD_PAD_TEMPLATE (pad));
2606
2607   return gst_caps_ref (GST_CAPS_ANY);
2608 }
2609
2610 /**
2611  * gst_pad_get_peer:
2612  * @pad: a #GstPad to get the peer of.
2613  *
2614  * Gets the peer of @pad. This function refs the peer pad so
2615  * you need to unref it after use.
2616  *
2617  * Returns: (transfer full): the peer #GstPad. Unref after usage.
2618  *
2619  * MT safe.
2620  */
2621 GstPad *
2622 gst_pad_get_peer (GstPad * pad)
2623 {
2624   GstPad *result;
2625
2626   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2627
2628   GST_OBJECT_LOCK (pad);
2629   result = GST_PAD_PEER (pad);
2630   if (result)
2631     gst_object_ref (result);
2632   GST_OBJECT_UNLOCK (pad);
2633
2634   return result;
2635 }
2636
2637 /**
2638  * gst_pad_get_allowed_caps:
2639  * @pad: a #GstPad.
2640  *
2641  * Gets the capabilities of the allowed media types that can flow through
2642  * @pad and its peer.
2643  *
2644  * The allowed capabilities is calculated as the intersection of the results of
2645  * calling gst_pad_query_caps() on @pad and its peer. The caller owns a reference
2646  * on the resulting caps.
2647  *
2648  * Returns: (transfer full) (nullable): the allowed #GstCaps of the
2649  *     pad link. Unref the caps when you no longer need it. This
2650  *     function returns %NULL when @pad has no peer.
2651  *
2652  * MT safe.
2653  */
2654 GstCaps *
2655 gst_pad_get_allowed_caps (GstPad * pad)
2656 {
2657   GstCaps *mycaps;
2658   GstCaps *caps = NULL;
2659   GstQuery *query;
2660
2661   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2662
2663   GST_OBJECT_LOCK (pad);
2664   if (G_UNLIKELY (GST_PAD_PEER (pad) == NULL))
2665     goto no_peer;
2666   GST_OBJECT_UNLOCK (pad);
2667
2668   GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "getting allowed caps");
2669
2670   mycaps = gst_pad_query_caps (pad, NULL);
2671
2672   /* Query peer caps */
2673   query = gst_query_new_caps (mycaps);
2674   gst_pad_peer_query (pad, query);
2675   gst_query_parse_caps_result (query, &caps);
2676   gst_caps_ref (caps);
2677   gst_query_unref (query);
2678
2679   gst_caps_unref (mycaps);
2680
2681   GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad, "allowed caps %" GST_PTR_FORMAT,
2682       caps);
2683
2684   return caps;
2685
2686 no_peer:
2687   {
2688     GST_CAT_DEBUG_OBJECT (GST_CAT_PROPERTIES, pad, "no peer");
2689     GST_OBJECT_UNLOCK (pad);
2690
2691     return NULL;
2692   }
2693 }
2694
2695 /**
2696  * gst_pad_iterate_internal_links_default:
2697  * @pad: the #GstPad to get the internal links of.
2698  * @parent: (allow-none): the parent of @pad or %NULL
2699  *
2700  * Iterate the list of pads to which the given pad is linked to inside of
2701  * the parent element.
2702  * This is the default handler, and thus returns an iterator of all of the
2703  * pads inside the parent element with opposite direction.
2704  *
2705  * The caller must free this iterator after use with gst_iterator_free().
2706  *
2707  * Returns: (nullable): a #GstIterator of #GstPad, or %NULL if @pad
2708  * has no parent. Unref each returned pad with gst_object_unref().
2709  */
2710 GstIterator *
2711 gst_pad_iterate_internal_links_default (GstPad * pad, GstObject * parent)
2712 {
2713   GstIterator *res;
2714   GList **padlist;
2715   guint32 *cookie;
2716   GMutex *lock;
2717   gpointer owner;
2718   GstElement *eparent;
2719
2720   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2721
2722   if (parent != NULL && GST_IS_ELEMENT (parent)) {
2723     eparent = GST_ELEMENT_CAST (gst_object_ref (parent));
2724   } else {
2725     GST_OBJECT_LOCK (pad);
2726     eparent = GST_PAD_PARENT (pad);
2727     if (!eparent || !GST_IS_ELEMENT (eparent))
2728       goto no_parent;
2729
2730     gst_object_ref (eparent);
2731     GST_OBJECT_UNLOCK (pad);
2732   }
2733
2734   if (pad->direction == GST_PAD_SRC)
2735     padlist = &eparent->sinkpads;
2736   else
2737     padlist = &eparent->srcpads;
2738
2739   GST_DEBUG_OBJECT (pad, "Making iterator");
2740
2741   cookie = &eparent->pads_cookie;
2742   owner = eparent;
2743   lock = GST_OBJECT_GET_LOCK (eparent);
2744
2745   res = gst_iterator_new_list (GST_TYPE_PAD,
2746       lock, cookie, padlist, (GObject *) owner, NULL);
2747
2748   gst_object_unref (owner);
2749
2750   return res;
2751
2752   /* ERRORS */
2753 no_parent:
2754   {
2755     GST_OBJECT_UNLOCK (pad);
2756     GST_DEBUG_OBJECT (pad, "no parent element");
2757     return NULL;
2758   }
2759 }
2760
2761 /**
2762  * gst_pad_iterate_internal_links:
2763  * @pad: the GstPad to get the internal links of.
2764  *
2765  * Gets an iterator for the pads to which the given pad is linked to inside
2766  * of the parent element.
2767  *
2768  * Each #GstPad element yielded by the iterator will have its refcount increased,
2769  * so unref after use.
2770  *
2771  * Free-function: gst_iterator_free
2772  *
2773  * Returns: (transfer full) (nullable): a new #GstIterator of #GstPad
2774  *     or %NULL when the pad does not have an iterator function
2775  *     configured. Use gst_iterator_free() after usage.
2776  */
2777 GstIterator *
2778 gst_pad_iterate_internal_links (GstPad * pad)
2779 {
2780   GstIterator *res = NULL;
2781   GstObject *parent;
2782
2783   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
2784
2785   GST_OBJECT_LOCK (pad);
2786   ACQUIRE_PARENT (pad, parent, no_parent);
2787   GST_OBJECT_UNLOCK (pad);
2788
2789   if (GST_PAD_ITERINTLINKFUNC (pad))
2790     res = GST_PAD_ITERINTLINKFUNC (pad) (pad, parent);
2791
2792   RELEASE_PARENT (parent);
2793
2794   return res;
2795
2796   /* ERRORS */
2797 no_parent:
2798   {
2799     GST_DEBUG_OBJECT (pad, "no parent");
2800     GST_OBJECT_UNLOCK (pad);
2801     return NULL;
2802   }
2803 }
2804
2805 /**
2806  * gst_pad_forward:
2807  * @pad: a #GstPad
2808  * @forward: (scope call): a #GstPadForwardFunction
2809  * @user_data: user data passed to @forward
2810  *
2811  * Calls @forward for all internally linked pads of @pad. This function deals with
2812  * dynamically changing internal pads and will make sure that the @forward
2813  * function is only called once for each pad.
2814  *
2815  * When @forward returns %TRUE, no further pads will be processed.
2816  *
2817  * Returns: %TRUE if one of the dispatcher functions returned %TRUE.
2818  */
2819 gboolean
2820 gst_pad_forward (GstPad * pad, GstPadForwardFunction forward,
2821     gpointer user_data)
2822 {
2823   gboolean result = FALSE;
2824   GstIterator *iter;
2825   gboolean done = FALSE;
2826   GValue item = { 0, };
2827   GList *pushed_pads = NULL;
2828
2829   iter = gst_pad_iterate_internal_links (pad);
2830
2831   if (!iter)
2832     goto no_iter;
2833
2834   while (!done) {
2835     switch (gst_iterator_next (iter, &item)) {
2836       case GST_ITERATOR_OK:
2837       {
2838         GstPad *intpad;
2839
2840         intpad = g_value_get_object (&item);
2841
2842         /* if already pushed, skip. FIXME, find something faster to tag pads */
2843         if (intpad == NULL || g_list_find (pushed_pads, intpad)) {
2844           g_value_reset (&item);
2845           break;
2846         }
2847
2848         GST_LOG_OBJECT (pad, "calling forward function on pad %s:%s",
2849             GST_DEBUG_PAD_NAME (intpad));
2850         done = result = forward (intpad, user_data);
2851
2852         pushed_pads = g_list_prepend (pushed_pads, intpad);
2853
2854         g_value_reset (&item);
2855         break;
2856       }
2857       case GST_ITERATOR_RESYNC:
2858         /* We don't reset the result here because we don't push the event
2859          * again on pads that got the event already and because we need
2860          * to consider the result of the previous pushes */
2861         gst_iterator_resync (iter);
2862         break;
2863       case GST_ITERATOR_ERROR:
2864         GST_ERROR_OBJECT (pad, "Could not iterate over internally linked pads");
2865         done = TRUE;
2866         break;
2867       case GST_ITERATOR_DONE:
2868         done = TRUE;
2869         break;
2870     }
2871   }
2872   g_value_unset (&item);
2873   gst_iterator_free (iter);
2874
2875   g_list_free (pushed_pads);
2876
2877 no_iter:
2878   return result;
2879 }
2880
2881 typedef struct
2882 {
2883   GstEvent *event;
2884   gboolean result;
2885   gboolean dispatched;
2886 } EventData;
2887
2888 static gboolean
2889 event_forward_func (GstPad * pad, EventData * data)
2890 {
2891   /* for each pad we send to, we should ref the event; it's up
2892    * to downstream to unref again when handled. */
2893   GST_LOG_OBJECT (pad, "Reffing and pushing event %p (%s) to %s:%s",
2894       data->event, GST_EVENT_TYPE_NAME (data->event), GST_DEBUG_PAD_NAME (pad));
2895
2896   data->result |= gst_pad_push_event (pad, gst_event_ref (data->event));
2897
2898   data->dispatched = TRUE;
2899
2900   /* don't stop */
2901   return FALSE;
2902 }
2903
2904 /**
2905  * gst_pad_event_default:
2906  * @pad: a #GstPad to call the default event handler on.
2907  * @parent: (allow-none): the parent of @pad or %NULL
2908  * @event: (transfer full): the #GstEvent to handle.
2909  *
2910  * Invokes the default event handler for the given pad.
2911  *
2912  * The EOS event will pause the task associated with @pad before it is forwarded
2913  * to all internally linked pads,
2914  *
2915  * The event is sent to all pads internally linked to @pad. This function
2916  * takes ownership of @event.
2917  *
2918  * Returns: %TRUE if the event was sent successfully.
2919  */
2920 gboolean
2921 gst_pad_event_default (GstPad * pad, GstObject * parent, GstEvent * event)
2922 {
2923   gboolean result, forward = TRUE;
2924
2925   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
2926   g_return_val_if_fail (event != NULL, FALSE);
2927
2928   GST_LOG_OBJECT (pad, "default event handler for event %" GST_PTR_FORMAT,
2929       event);
2930
2931   switch (GST_EVENT_TYPE (event)) {
2932     case GST_EVENT_CAPS:
2933       forward = GST_PAD_IS_PROXY_CAPS (pad);
2934       result = TRUE;
2935       break;
2936     default:
2937       break;
2938   }
2939
2940   if (forward) {
2941     EventData data;
2942
2943     data.event = event;
2944     data.dispatched = FALSE;
2945     data.result = FALSE;
2946
2947     gst_pad_forward (pad, (GstPadForwardFunction) event_forward_func, &data);
2948
2949     /* for sinkpads without a parent element or without internal links, nothing
2950      * will be dispatched but we still want to return TRUE. */
2951     if (data.dispatched)
2952       result = data.result;
2953     else
2954       result = TRUE;
2955   }
2956
2957   gst_event_unref (event);
2958
2959   return result;
2960 }
2961
2962 /* Default accept caps implementation just checks against
2963  * the allowed caps for the pad */
2964 static gboolean
2965 gst_pad_query_accept_caps_default (GstPad * pad, GstQuery * query)
2966 {
2967   /* get the caps and see if it intersects to something not empty */
2968   GstCaps *caps, *allowed;
2969   gboolean result;
2970
2971   GST_DEBUG_OBJECT (pad, "query accept-caps %" GST_PTR_FORMAT, query);
2972
2973   /* first forward the query to internally linked pads when we are dealing with
2974    * a PROXY CAPS */
2975   if (GST_PAD_IS_PROXY_CAPS (pad)) {
2976     if ((result = gst_pad_proxy_query_accept_caps (pad, query))) {
2977       goto done;
2978     }
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   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4450   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
4451   g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
4452
4453   return gst_pad_push_data (pad,
4454       GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH, buffer);
4455 }
4456
4457 /**
4458  * gst_pad_push_list:
4459  * @pad: a source #GstPad, returns #GST_FLOW_ERROR if not.
4460  * @list: (transfer full): the #GstBufferList to push returns GST_FLOW_ERROR
4461  *     if not.
4462  *
4463  * Pushes a buffer list to the peer of @pad.
4464  *
4465  * This function will call installed block probes before triggering any
4466  * installed data probes.
4467  *
4468  * The function proceeds calling the chain function on the peer pad and returns
4469  * the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will
4470  * be returned. If the peer pad does not have any installed chainlist function
4471  * every group buffer of the list will be merged into a normal #GstBuffer and
4472  * chained via gst_pad_chain().
4473  *
4474  * In all cases, success or failure, the caller loses its reference to @list
4475  * after calling this function.
4476  *
4477  * Returns: a #GstFlowReturn from the peer pad.
4478  *
4479  * MT safe.
4480  */
4481 GstFlowReturn
4482 gst_pad_push_list (GstPad * pad, GstBufferList * list)
4483 {
4484   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4485   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
4486   g_return_val_if_fail (GST_IS_BUFFER_LIST (list), GST_FLOW_ERROR);
4487
4488   return gst_pad_push_data (pad,
4489       GST_PAD_PROBE_TYPE_BUFFER_LIST | GST_PAD_PROBE_TYPE_PUSH, list);
4490 }
4491
4492 static GstFlowReturn
4493 gst_pad_get_range_unchecked (GstPad * pad, guint64 offset, guint size,
4494     GstBuffer ** buffer)
4495 {
4496   GstFlowReturn ret;
4497   GstPadGetRangeFunction getrangefunc;
4498   GstObject *parent;
4499   GstBuffer *res_buf;
4500
4501   GST_PAD_STREAM_LOCK (pad);
4502
4503   GST_OBJECT_LOCK (pad);
4504   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4505     goto flushing;
4506
4507   if (G_UNLIKELY (GST_PAD_MODE (pad) != GST_PAD_MODE_PULL))
4508     goto wrong_mode;
4509
4510   if (G_UNLIKELY ((ret = check_sticky (pad, NULL))) != GST_FLOW_OK)
4511     goto events_error;
4512
4513   res_buf = *buffer;
4514
4515   /* when one of the probes returns DROPPED, probe_stopped will be called
4516    * and we skip calling the getrange function, res_buf should then contain a
4517    * valid result buffer */
4518   PROBE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BLOCK,
4519       res_buf, offset, size, probe_stopped);
4520
4521   /* recheck sticky events because the probe might have cause a relink */
4522   if (G_UNLIKELY ((ret = check_sticky (pad, NULL))) != GST_FLOW_OK)
4523     goto events_error;
4524
4525   ACQUIRE_PARENT (pad, parent, no_parent);
4526   GST_OBJECT_UNLOCK (pad);
4527
4528   if (G_UNLIKELY ((getrangefunc = GST_PAD_GETRANGEFUNC (pad)) == NULL))
4529     goto no_function;
4530
4531   GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4532       "calling getrangefunc %s, offset %"
4533       G_GUINT64_FORMAT ", size %u",
4534       GST_DEBUG_FUNCPTR_NAME (getrangefunc), offset, size);
4535
4536   ret = getrangefunc (pad, parent, offset, size, &res_buf);
4537
4538   RELEASE_PARENT (parent);
4539
4540   GST_OBJECT_LOCK (pad);
4541   if (G_UNLIKELY (ret != GST_FLOW_OK))
4542     goto get_range_failed;
4543
4544   /* can only fire the signal if we have a valid buffer */
4545 probed_data:
4546   PROBE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BUFFER,
4547       res_buf, offset, size, probe_stopped_unref);
4548   pad->ABI.abi.last_flowret = ret;
4549   GST_OBJECT_UNLOCK (pad);
4550
4551   GST_PAD_STREAM_UNLOCK (pad);
4552
4553   *buffer = res_buf;
4554
4555   return ret;
4556
4557   /* ERRORS */
4558 flushing:
4559   {
4560     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4561         "getrange, but pad was flushing");
4562     pad->ABI.abi.last_flowret = GST_FLOW_FLUSHING;
4563     GST_OBJECT_UNLOCK (pad);
4564     GST_PAD_STREAM_UNLOCK (pad);
4565     return GST_FLOW_FLUSHING;
4566   }
4567 wrong_mode:
4568   {
4569     g_critical ("getrange on pad %s:%s but it was not activated in pull mode",
4570         GST_DEBUG_PAD_NAME (pad));
4571     pad->ABI.abi.last_flowret = GST_FLOW_ERROR;
4572     GST_OBJECT_UNLOCK (pad);
4573     GST_PAD_STREAM_UNLOCK (pad);
4574     return GST_FLOW_ERROR;
4575   }
4576 events_error:
4577   {
4578     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "error pushing events");
4579     pad->ABI.abi.last_flowret = ret;
4580     GST_OBJECT_UNLOCK (pad);
4581     GST_PAD_STREAM_UNLOCK (pad);
4582     return ret;
4583   }
4584 no_parent:
4585   {
4586     GST_DEBUG_OBJECT (pad, "no parent");
4587     pad->ABI.abi.last_flowret = GST_FLOW_FLUSHING;
4588     GST_OBJECT_UNLOCK (pad);
4589     GST_PAD_STREAM_UNLOCK (pad);
4590     return GST_FLOW_FLUSHING;
4591   }
4592 no_function:
4593   {
4594     g_critical ("getrange on pad %s:%s but it has no getrangefunction",
4595         GST_DEBUG_PAD_NAME (pad));
4596     RELEASE_PARENT (parent);
4597     GST_PAD_STREAM_UNLOCK (pad);
4598     return GST_FLOW_NOT_SUPPORTED;
4599   }
4600 probe_stopped:
4601   {
4602     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4603         "probe returned %s", gst_flow_get_name (ret));
4604     if (ret == GST_FLOW_CUSTOM_SUCCESS) {
4605       if (res_buf) {
4606         /* the probe filled the buffer and asks us to not call the getrange
4607          * anymore, we continue with the post probes then. */
4608         GST_DEBUG_OBJECT (pad, "handled buffer");
4609         ret = GST_FLOW_OK;
4610         goto probed_data;
4611       } else {
4612         /* no buffer, we are EOS */
4613         GST_DEBUG_OBJECT (pad, "no buffer, return EOS");
4614         ret = GST_FLOW_EOS;
4615       }
4616     }
4617     pad->ABI.abi.last_flowret = ret;
4618     GST_OBJECT_UNLOCK (pad);
4619     GST_PAD_STREAM_UNLOCK (pad);
4620
4621     return ret;
4622   }
4623 probe_stopped_unref:
4624   {
4625     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4626         "probe returned %s", gst_flow_get_name (ret));
4627     /* if we drop here, it signals EOS */
4628     if (ret == GST_FLOW_CUSTOM_SUCCESS)
4629       ret = GST_FLOW_EOS;
4630     pad->ABI.abi.last_flowret = ret;
4631     GST_OBJECT_UNLOCK (pad);
4632     GST_PAD_STREAM_UNLOCK (pad);
4633     if (*buffer == NULL)
4634       gst_buffer_unref (res_buf);
4635     return ret;
4636   }
4637 get_range_failed:
4638   {
4639     pad->ABI.abi.last_flowret = ret;
4640     GST_OBJECT_UNLOCK (pad);
4641     GST_PAD_STREAM_UNLOCK (pad);
4642     GST_CAT_LEVEL_LOG (GST_CAT_SCHEDULING,
4643         (ret >= GST_FLOW_EOS) ? GST_LEVEL_INFO : GST_LEVEL_WARNING,
4644         pad, "getrange failed, flow: %s", gst_flow_get_name (ret));
4645     return ret;
4646   }
4647 }
4648
4649 /**
4650  * gst_pad_get_range:
4651  * @pad: a src #GstPad, returns #GST_FLOW_ERROR if not.
4652  * @offset: The start offset of the buffer
4653  * @size: The length of the buffer
4654  * @buffer: (out callee-allocates): a pointer to hold the #GstBuffer,
4655  *     returns #GST_FLOW_ERROR if %NULL.
4656  *
4657  * When @pad is flushing this function returns #GST_FLOW_FLUSHING
4658  * immediately and @buffer is %NULL.
4659  *
4660  * Calls the getrange function of @pad, see #GstPadGetRangeFunction for a
4661  * description of a getrange function. If @pad has no getrange function
4662  * installed (see gst_pad_set_getrange_function()) this function returns
4663  * #GST_FLOW_NOT_SUPPORTED.
4664  *
4665  * If @buffer points to a variable holding %NULL, a valid new #GstBuffer will be
4666  * placed in @buffer when this function returns #GST_FLOW_OK. The new buffer
4667  * must be freed with gst_buffer_unref() after usage.
4668  *
4669  * When @buffer points to a variable that points to a valid #GstBuffer, the
4670  * buffer will be filled with the result data when this function returns
4671  * #GST_FLOW_OK. If the provided buffer is larger than @size, only
4672  * @size bytes will be filled in the result buffer and its size will be updated
4673  * accordingly.
4674  *
4675  * Note that less than @size bytes can be returned in @buffer when, for example,
4676  * an EOS condition is near or when @buffer is not large enough to hold @size
4677  * bytes. The caller should check the result buffer size to get the result size.
4678  *
4679  * When this function returns any other result value than #GST_FLOW_OK, @buffer
4680  * will be unchanged.
4681  *
4682  * This is a lowlevel function. Usually gst_pad_pull_range() is used.
4683  *
4684  * Returns: a #GstFlowReturn from the pad.
4685  *
4686  * MT safe.
4687  */
4688 GstFlowReturn
4689 gst_pad_get_range (GstPad * pad, guint64 offset, guint size,
4690     GstBuffer ** buffer)
4691 {
4692   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4693   g_return_val_if_fail (GST_PAD_IS_SRC (pad), GST_FLOW_ERROR);
4694   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
4695   g_return_val_if_fail (*buffer == NULL || (GST_IS_BUFFER (*buffer)
4696           && gst_buffer_get_size (*buffer) >= size), GST_FLOW_ERROR);
4697
4698   return gst_pad_get_range_unchecked (pad, offset, size, buffer);
4699 }
4700
4701 /**
4702  * gst_pad_pull_range:
4703  * @pad: a sink #GstPad, returns GST_FLOW_ERROR if not.
4704  * @offset: The start offset of the buffer
4705  * @size: The length of the buffer
4706  * @buffer: (out callee-allocates): a pointer to hold the #GstBuffer, returns
4707  *     GST_FLOW_ERROR if %NULL.
4708  *
4709  * Pulls a @buffer from the peer pad or fills up a provided buffer.
4710  *
4711  * This function will first trigger the pad block signal if it was
4712  * installed.
4713  *
4714  * When @pad is not linked #GST_FLOW_NOT_LINKED is returned else this
4715  * function returns the result of gst_pad_get_range() on the peer pad.
4716  * See gst_pad_get_range() for a list of return values and for the
4717  * semantics of the arguments of this function.
4718  *
4719  * If @buffer points to a variable holding %NULL, a valid new #GstBuffer will be
4720  * placed in @buffer when this function returns #GST_FLOW_OK. The new buffer
4721  * must be freed with gst_buffer_unref() after usage. When this function
4722  * returns any other result value, @buffer will still point to %NULL.
4723  *
4724  * When @buffer points to a variable that points to a valid #GstBuffer, the
4725  * buffer will be filled with the result data when this function returns
4726  * #GST_FLOW_OK. When this function returns any other result value,
4727  * @buffer will be unchanged. If the provided buffer is larger than @size, only
4728  * @size bytes will be filled in the result buffer and its size will be updated
4729  * accordingly.
4730  *
4731  * Note that less than @size bytes can be returned in @buffer when, for example,
4732  * an EOS condition is near or when @buffer is not large enough to hold @size
4733  * bytes. The caller should check the result buffer size to get the result size.
4734  *
4735  * Returns: a #GstFlowReturn from the peer pad.
4736  *
4737  * MT safe.
4738  */
4739 GstFlowReturn
4740 gst_pad_pull_range (GstPad * pad, guint64 offset, guint size,
4741     GstBuffer ** buffer)
4742 {
4743   GstPad *peer;
4744   GstFlowReturn ret;
4745   GstBuffer *res_buf;
4746
4747   g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
4748   g_return_val_if_fail (GST_PAD_IS_SINK (pad), GST_FLOW_ERROR);
4749   g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
4750   g_return_val_if_fail (*buffer == NULL || (GST_IS_BUFFER (*buffer)
4751           && gst_buffer_get_size (*buffer) >= size), GST_FLOW_ERROR);
4752
4753   GST_OBJECT_LOCK (pad);
4754   if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
4755     goto flushing;
4756
4757   if (G_UNLIKELY (GST_PAD_MODE (pad) != GST_PAD_MODE_PULL))
4758     goto wrong_mode;
4759
4760   res_buf = *buffer;
4761
4762   /* when one of the probes returns DROPPED, probe_stopped will be
4763    * called and we skip calling the peer getrange function. *buffer should then
4764    * contain a valid buffer */
4765   PROBE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BLOCK,
4766       res_buf, offset, size, probe_stopped);
4767
4768   if (G_UNLIKELY ((peer = GST_PAD_PEER (pad)) == NULL))
4769     goto not_linked;
4770
4771   gst_object_ref (peer);
4772   pad->priv->using++;
4773   GST_OBJECT_UNLOCK (pad);
4774
4775   ret = gst_pad_get_range_unchecked (peer, offset, size, &res_buf);
4776
4777   gst_object_unref (peer);
4778
4779   GST_OBJECT_LOCK (pad);
4780   pad->priv->using--;
4781   pad->ABI.abi.last_flowret = ret;
4782   if (pad->priv->using == 0) {
4783     /* pad is not active anymore, trigger idle callbacks */
4784     PROBE_NO_DATA (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_IDLE,
4785         probe_stopped_unref, ret);
4786   }
4787
4788   if (G_UNLIKELY (ret != GST_FLOW_OK))
4789     goto pull_range_failed;
4790
4791 probed_data:
4792   PROBE_PULL (pad, GST_PAD_PROBE_TYPE_PULL | GST_PAD_PROBE_TYPE_BUFFER,
4793       res_buf, offset, size, probe_stopped_unref);
4794
4795   GST_OBJECT_UNLOCK (pad);
4796
4797   *buffer = res_buf;
4798
4799   return ret;
4800
4801   /* ERROR recovery here */
4802 flushing:
4803   {
4804     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4805         "pullrange, but pad was flushing");
4806     pad->ABI.abi.last_flowret = GST_FLOW_FLUSHING;
4807     GST_OBJECT_UNLOCK (pad);
4808     return GST_FLOW_FLUSHING;
4809   }
4810 wrong_mode:
4811   {
4812     g_critical ("pullrange on pad %s:%s but it was not activated in pull mode",
4813         GST_DEBUG_PAD_NAME (pad));
4814     pad->ABI.abi.last_flowret = GST_FLOW_ERROR;
4815     GST_OBJECT_UNLOCK (pad);
4816     return GST_FLOW_ERROR;
4817   }
4818 probe_stopped:
4819   {
4820     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad, "pre probe returned %s",
4821         gst_flow_get_name (ret));
4822     if (ret == GST_FLOW_CUSTOM_SUCCESS) {
4823       if (res_buf) {
4824         /* the probe filled the buffer and asks us to not forward to the peer
4825          * anymore, we continue with the post probes then */
4826         GST_DEBUG_OBJECT (pad, "handled buffer");
4827         ret = GST_FLOW_OK;
4828         goto probed_data;
4829       } else {
4830         /* no buffer, we are EOS then */
4831         GST_DEBUG_OBJECT (pad, "no buffer, return EOS");
4832         ret = GST_FLOW_EOS;
4833       }
4834     }
4835     pad->ABI.abi.last_flowret = ret;
4836     GST_OBJECT_UNLOCK (pad);
4837     return ret;
4838   }
4839 not_linked:
4840   {
4841     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4842         "pulling range, but it was not linked");
4843     pad->ABI.abi.last_flowret = GST_FLOW_NOT_LINKED;
4844     GST_OBJECT_UNLOCK (pad);
4845     return GST_FLOW_NOT_LINKED;
4846   }
4847 pull_range_failed:
4848   {
4849     pad->ABI.abi.last_flowret = ret;
4850     GST_OBJECT_UNLOCK (pad);
4851     GST_CAT_LEVEL_LOG (GST_CAT_SCHEDULING,
4852         (ret >= GST_FLOW_EOS) ? GST_LEVEL_INFO : GST_LEVEL_WARNING,
4853         pad, "pullrange failed, flow: %s", gst_flow_get_name (ret));
4854     return ret;
4855   }
4856 probe_stopped_unref:
4857   {
4858     GST_CAT_LOG_OBJECT (GST_CAT_SCHEDULING, pad,
4859         "post probe returned %s", gst_flow_get_name (ret));
4860
4861     /* if we drop here, it signals EOS */
4862     if (ret == GST_FLOW_CUSTOM_SUCCESS)
4863       ret = GST_FLOW_EOS;
4864
4865     pad->ABI.abi.last_flowret = ret;
4866     GST_OBJECT_UNLOCK (pad);
4867
4868     if (*buffer == NULL)
4869       gst_buffer_unref (res_buf);
4870     return ret;
4871   }
4872 }
4873
4874 /* must be called with pad object lock */
4875 static GstFlowReturn
4876 store_sticky_event (GstPad * pad, GstEvent * event)
4877 {
4878   guint i, len;
4879   GstEventType type;
4880   GArray *events;
4881   gboolean res = FALSE;
4882   const gchar *name = NULL;
4883   gboolean insert = TRUE;
4884
4885   type = GST_EVENT_TYPE (event);
4886
4887   /* Store all sticky events except SEGMENT/EOS when we're flushing,
4888    * otherwise they can be dropped and nothing would ever resend them.
4889    * Only do that for activated pads though, everything else is a bug!
4890    */
4891   if (G_UNLIKELY (GST_PAD_MODE (pad) == GST_PAD_MODE_NONE
4892           || (GST_PAD_IS_FLUSHING (pad) && (type == GST_EVENT_SEGMENT
4893                   || type == GST_EVENT_EOS))))
4894     goto flushed;
4895
4896   /* Unset the EOS flag when received STREAM_START event, so pad can
4897    * store sticky event and then push it later */
4898   if (type == GST_EVENT_STREAM_START) {
4899     GST_LOG_OBJECT (pad, "Removing pending EOS events");
4900     remove_event_by_type (pad, GST_EVENT_EOS);
4901     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_EOS);
4902   }
4903
4904   if (G_UNLIKELY (GST_PAD_IS_EOS (pad)))
4905     goto eos;
4906
4907   if (type & GST_EVENT_TYPE_STICKY_MULTI)
4908     name = gst_structure_get_name (gst_event_get_structure (event));
4909
4910   events = pad->priv->events;
4911   len = events->len;
4912
4913   for (i = 0; i < len; i++) {
4914     PadEvent *ev = &g_array_index (events, PadEvent, i);
4915
4916     if (ev->event == NULL)
4917       continue;
4918
4919     if (type == GST_EVENT_TYPE (ev->event)) {
4920       /* matching types, check matching name if needed */
4921       if (name && !gst_event_has_name (ev->event, name))
4922         continue;
4923
4924       /* overwrite */
4925       if ((res = gst_event_replace (&ev->event, event)))
4926         ev->received = FALSE;
4927
4928       insert = FALSE;
4929       break;
4930     }
4931
4932     if (type < GST_EVENT_TYPE (ev->event) || (type != GST_EVENT_TYPE (ev->event)
4933             && GST_EVENT_TYPE (ev->event) == GST_EVENT_EOS)) {
4934       /* STREAM_START, CAPS and SEGMENT must be delivered in this order. By
4935        * storing the sticky ordered we can check that this is respected. */
4936       if (G_UNLIKELY (GST_EVENT_TYPE (ev->event) <= GST_EVENT_SEGMENT
4937               || GST_EVENT_TYPE (ev->event) == GST_EVENT_EOS))
4938         g_warning (G_STRLOC
4939             ":%s:<%s:%s> Sticky event misordering, got '%s' before '%s'",
4940             G_STRFUNC, GST_DEBUG_PAD_NAME (pad),
4941             gst_event_type_get_name (GST_EVENT_TYPE (ev->event)),
4942             gst_event_type_get_name (type));
4943       break;
4944     }
4945   }
4946   if (insert) {
4947     PadEvent ev;
4948     ev.event = gst_event_ref (event);
4949     ev.received = FALSE;
4950     g_array_insert_val (events, i, ev);
4951     res = TRUE;
4952   }
4953
4954   if (res) {
4955     pad->priv->events_cookie++;
4956     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
4957
4958     GST_LOG_OBJECT (pad, "stored sticky event %s", GST_EVENT_TYPE_NAME (event));
4959
4960     switch (GST_EVENT_TYPE (event)) {
4961       case GST_EVENT_CAPS:
4962         GST_OBJECT_UNLOCK (pad);
4963
4964         GST_DEBUG_OBJECT (pad, "notify caps");
4965         g_object_notify_by_pspec ((GObject *) pad, pspec_caps);
4966
4967         GST_OBJECT_LOCK (pad);
4968         break;
4969       default:
4970         break;
4971     }
4972   }
4973   if (type == GST_EVENT_EOS) {
4974     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_EOS);
4975     pad->ABI.abi.last_flowret = GST_FLOW_EOS;
4976   }
4977
4978   return GST_PAD_IS_FLUSHING (pad) ? GST_FLOW_FLUSHING : GST_FLOW_OK;
4979
4980   /* ERRORS */
4981 flushed:
4982   {
4983     GST_DEBUG_OBJECT (pad, "pad is flushing");
4984     return GST_FLOW_FLUSHING;
4985   }
4986 eos:
4987   {
4988     GST_DEBUG_OBJECT (pad, "pad is EOS");
4989     return GST_FLOW_EOS;
4990   }
4991 }
4992
4993 /**
4994  * gst_pad_store_sticky_event:
4995  * @pad: a #GstPad
4996  * @event: a #GstEvent
4997  *
4998  * Store the sticky @event on @pad
4999  *
5000  * Returns: #GST_FLOW_OK on success, #GST_FLOW_FLUSHING when the pad
5001  * was flushing or #GST_FLOW_EOS when the pad was EOS.
5002  *
5003  * Since: 1.2
5004  */
5005 GstFlowReturn
5006 gst_pad_store_sticky_event (GstPad * pad, GstEvent * event)
5007 {
5008   GstFlowReturn ret;
5009
5010   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5011   g_return_val_if_fail (GST_IS_EVENT (event), FALSE);
5012
5013   GST_OBJECT_LOCK (pad);
5014   ret = store_sticky_event (pad, event);
5015   GST_OBJECT_UNLOCK (pad);
5016
5017   return ret;
5018 }
5019
5020 static gboolean
5021 sticky_changed (GstPad * pad, PadEvent * ev, gpointer user_data)
5022 {
5023   PushStickyData *data = user_data;
5024
5025   /* Forward all sticky events before our current one that are pending */
5026   if (ev->event != data->event
5027       && GST_EVENT_TYPE (ev->event) < GST_EVENT_TYPE (data->event))
5028     return push_sticky (pad, ev, data);
5029
5030   return TRUE;
5031 }
5032
5033 /* should be called with pad LOCK */
5034 static GstFlowReturn
5035 gst_pad_push_event_unchecked (GstPad * pad, GstEvent * event,
5036     GstPadProbeType type)
5037 {
5038   GstFlowReturn ret;
5039   GstPad *peerpad;
5040   GstEventType event_type;
5041
5042   /* pass the adjusted event on. We need to do this even if
5043    * there is no peer pad because of the probes. */
5044   event = apply_pad_offset (pad, event, GST_PAD_IS_SINK (pad));
5045
5046   /* Two checks to be made:
5047    * . (un)set the FLUSHING flag for flushing events,
5048    * . handle pad blocking */
5049   event_type = GST_EVENT_TYPE (event);
5050   switch (event_type) {
5051     case GST_EVENT_FLUSH_START:
5052       GST_PAD_SET_FLUSHING (pad);
5053
5054       GST_PAD_BLOCK_BROADCAST (pad);
5055       type |= GST_PAD_PROBE_TYPE_EVENT_FLUSH;
5056       break;
5057     case GST_EVENT_FLUSH_STOP:
5058       if (G_UNLIKELY (!GST_PAD_IS_ACTIVE (pad)))
5059         goto inactive;
5060
5061       GST_PAD_UNSET_FLUSHING (pad);
5062
5063       /* Remove sticky EOS events */
5064       GST_LOG_OBJECT (pad, "Removing pending EOS events");
5065       remove_event_by_type (pad, GST_EVENT_EOS);
5066       remove_event_by_type (pad, GST_EVENT_SEGMENT);
5067       GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_EOS);
5068       pad->ABI.abi.last_flowret = GST_FLOW_OK;
5069
5070       type |= GST_PAD_PROBE_TYPE_EVENT_FLUSH;
5071       break;
5072     default:
5073     {
5074       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
5075         goto flushed;
5076
5077       /* No need to check for EOS here as either the caller (gst_pad_push_event())
5078        * checked already or this is called as part of pushing sticky events,
5079        * in which case we still want to forward the EOS event downstream.
5080        */
5081
5082       switch (GST_EVENT_TYPE (event)) {
5083         case GST_EVENT_RECONFIGURE:
5084           if (GST_PAD_IS_SINK (pad))
5085             GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
5086           break;
5087         default:
5088           break;
5089       }
5090       PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH |
5091           GST_PAD_PROBE_TYPE_BLOCK, event, probe_stopped);
5092       break;
5093     }
5094   }
5095
5096   /* send probes after modifying the events above */
5097   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH, event, probe_stopped);
5098
5099   /* recheck sticky events because the probe might have cause a relink */
5100   if (GST_PAD_HAS_PENDING_EVENTS (pad) && GST_PAD_IS_SRC (pad)
5101       && (GST_EVENT_IS_SERIALIZED (event)
5102           || GST_EVENT_IS_STICKY (event))) {
5103     PushStickyData data = { GST_FLOW_OK, FALSE, event };
5104     GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PENDING_EVENTS);
5105
5106     /* Push all sticky events before our current one
5107      * that have changed */
5108     events_foreach (pad, sticky_changed, &data);
5109   }
5110
5111   /* now check the peer pad */
5112   peerpad = GST_PAD_PEER (pad);
5113   if (peerpad == NULL)
5114     goto not_linked;
5115
5116   gst_object_ref (peerpad);
5117   pad->priv->using++;
5118   GST_OBJECT_UNLOCK (pad);
5119
5120   GST_LOG_OBJECT (pad, "sending event %p (%s) to peerpad %" GST_PTR_FORMAT,
5121       event, gst_event_type_get_name (event_type), peerpad);
5122
5123   ret = gst_pad_send_event_unchecked (peerpad, event, type);
5124
5125   /* Note: we gave away ownership of the event at this point but we can still
5126    * print the old pointer */
5127   GST_LOG_OBJECT (pad,
5128       "sent event %p (%s) to peerpad %" GST_PTR_FORMAT ", ret %s", event,
5129       gst_event_type_get_name (event_type), peerpad, gst_flow_get_name (ret));
5130
5131   gst_object_unref (peerpad);
5132
5133   GST_OBJECT_LOCK (pad);
5134   pad->priv->using--;
5135   if (pad->priv->using == 0) {
5136     /* pad is not active anymore, trigger idle callbacks */
5137     PROBE_NO_DATA (pad, GST_PAD_PROBE_TYPE_PUSH | GST_PAD_PROBE_TYPE_IDLE,
5138         idle_probe_stopped, ret);
5139   }
5140   return ret;
5141
5142   /* ERROR handling */
5143 flushed:
5144   {
5145     GST_DEBUG_OBJECT (pad, "We're flushing");
5146     gst_event_unref (event);
5147     return GST_FLOW_FLUSHING;
5148   }
5149 inactive:
5150   {
5151     GST_DEBUG_OBJECT (pad, "flush-stop on inactive pad");
5152     gst_event_unref (event);
5153     return GST_FLOW_FLUSHING;
5154   }
5155 probe_stopped:
5156   {
5157     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
5158     if (ret != GST_FLOW_CUSTOM_SUCCESS_1)
5159       gst_event_unref (event);
5160
5161     switch (ret) {
5162       case GST_FLOW_CUSTOM_SUCCESS_1:
5163         GST_DEBUG_OBJECT (pad, "handled event");
5164         break;
5165       case GST_FLOW_CUSTOM_SUCCESS:
5166         GST_DEBUG_OBJECT (pad, "dropped event");
5167         break;
5168       default:
5169         GST_DEBUG_OBJECT (pad, "an error occurred %s", gst_flow_get_name (ret));
5170         break;
5171     }
5172     return ret;
5173   }
5174 not_linked:
5175   {
5176     GST_DEBUG_OBJECT (pad, "Dropping event %s because pad is not linked",
5177         gst_event_type_get_name (GST_EVENT_TYPE (event)));
5178     GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PENDING_EVENTS);
5179     gst_event_unref (event);
5180
5181     /* unlinked pads should not influence latency configuration */
5182     if (event_type == GST_EVENT_LATENCY)
5183       return GST_FLOW_OK;
5184
5185     return GST_FLOW_NOT_LINKED;
5186   }
5187 idle_probe_stopped:
5188   {
5189     GST_DEBUG_OBJECT (pad, "Idle probe returned %s", gst_flow_get_name (ret));
5190     return ret;
5191   }
5192 }
5193
5194 /**
5195  * gst_pad_push_event:
5196  * @pad: a #GstPad to push the event to.
5197  * @event: (transfer full): the #GstEvent to send to the pad.
5198  *
5199  * Sends the event to the peer of the given pad. This function is
5200  * mainly used by elements to send events to their peer
5201  * elements.
5202  *
5203  * This function takes ownership of the provided event so you should
5204  * gst_event_ref() it if you want to reuse the event after this call.
5205  *
5206  * Returns: %TRUE if the event was handled.
5207  *
5208  * MT safe.
5209  */
5210 gboolean
5211 gst_pad_push_event (GstPad * pad, GstEvent * event)
5212 {
5213   gboolean res = FALSE;
5214   GstPadProbeType type;
5215   gboolean sticky, serialized;
5216
5217   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5218   g_return_val_if_fail (GST_IS_EVENT (event), FALSE);
5219
5220   if (GST_PAD_IS_SRC (pad)) {
5221     if (G_UNLIKELY (!GST_EVENT_IS_DOWNSTREAM (event)))
5222       goto wrong_direction;
5223     type = GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM;
5224   } else if (GST_PAD_IS_SINK (pad)) {
5225     if (G_UNLIKELY (!GST_EVENT_IS_UPSTREAM (event)))
5226       goto wrong_direction;
5227     /* events pushed on sinkpad never are sticky */
5228     type = GST_PAD_PROBE_TYPE_EVENT_UPSTREAM;
5229   } else
5230     goto unknown_direction;
5231
5232   GST_OBJECT_LOCK (pad);
5233   sticky = GST_EVENT_IS_STICKY (event);
5234   serialized = GST_EVENT_IS_SERIALIZED (event);
5235
5236   if (sticky) {
5237     /* srcpad sticky events are stored immediately, the received flag is set
5238      * to FALSE and will be set to TRUE when we can successfully push the
5239      * event to the peer pad */
5240     switch (store_sticky_event (pad, event)) {
5241       case GST_FLOW_FLUSHING:
5242         goto flushed;
5243       case GST_FLOW_EOS:
5244         goto eos;
5245       default:
5246         break;
5247     }
5248   }
5249   if (GST_PAD_IS_SRC (pad) && (serialized || sticky)) {
5250     /* all serialized or sticky events on the srcpad trigger push of
5251      * sticky events */
5252     res = (check_sticky (pad, event) == GST_FLOW_OK);
5253   }
5254   if (!sticky) {
5255     GstFlowReturn ret;
5256
5257     /* other events are pushed right away */
5258     ret = gst_pad_push_event_unchecked (pad, event, type);
5259     /* dropped events by a probe are not an error */
5260     res = (ret == GST_FLOW_OK || ret == GST_FLOW_CUSTOM_SUCCESS
5261         || ret == GST_FLOW_CUSTOM_SUCCESS_1);
5262   } else {
5263     /* Errors in sticky event pushing are no problem and ignored here
5264      * as they will cause more meaningful errors during data flow.
5265      * For EOS events, that are not followed by data flow, we still
5266      * return FALSE here though.
5267      */
5268     if (GST_EVENT_TYPE (event) != GST_EVENT_EOS)
5269       res = TRUE;
5270     gst_event_unref (event);
5271   }
5272   GST_OBJECT_UNLOCK (pad);
5273
5274   return res;
5275
5276   /* ERROR handling */
5277 wrong_direction:
5278   {
5279     g_warning ("pad %s:%s pushing %s event in wrong direction",
5280         GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE_NAME (event));
5281     gst_event_unref (event);
5282     return FALSE;
5283   }
5284 unknown_direction:
5285   {
5286     g_warning ("pad %s:%s has invalid direction", GST_DEBUG_PAD_NAME (pad));
5287     gst_event_unref (event);
5288     return FALSE;
5289   }
5290 flushed:
5291   {
5292     GST_DEBUG_OBJECT (pad, "We're flushing");
5293     GST_OBJECT_UNLOCK (pad);
5294     gst_event_unref (event);
5295     return FALSE;
5296   }
5297 eos:
5298   {
5299     GST_DEBUG_OBJECT (pad, "We're EOS");
5300     GST_OBJECT_UNLOCK (pad);
5301     gst_event_unref (event);
5302     return FALSE;
5303   }
5304 }
5305
5306 /* Check if we can call the event function with the given event */
5307 static GstFlowReturn
5308 pre_eventfunc_check (GstPad * pad, GstEvent * event)
5309 {
5310   GstCaps *caps;
5311
5312   switch (GST_EVENT_TYPE (event)) {
5313     case GST_EVENT_CAPS:
5314     {
5315       /* backwards compatibility mode for caps */
5316       gst_event_parse_caps (event, &caps);
5317
5318       if (!gst_pad_query_accept_caps (pad, caps))
5319         goto not_accepted;
5320       break;
5321     }
5322     default:
5323       break;
5324   }
5325   return GST_FLOW_OK;
5326
5327   /* ERRORS */
5328 not_accepted:
5329   {
5330     GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, pad,
5331         "caps %" GST_PTR_FORMAT " not accepted", caps);
5332     return GST_FLOW_NOT_NEGOTIATED;
5333   }
5334 }
5335
5336 static GstFlowReturn
5337 gst_pad_send_event_unchecked (GstPad * pad, GstEvent * event,
5338     GstPadProbeType type)
5339 {
5340   GstFlowReturn ret;
5341   GstEventType event_type;
5342   gboolean serialized, need_unlock = FALSE, sticky;
5343   GstPadEventFunction eventfunc;
5344   GstObject *parent;
5345
5346   GST_OBJECT_LOCK (pad);
5347
5348   event = apply_pad_offset (pad, event, GST_PAD_IS_SRC (pad));
5349
5350   if (GST_PAD_IS_SINK (pad))
5351     serialized = GST_EVENT_IS_SERIALIZED (event);
5352   else
5353     serialized = FALSE;
5354   sticky = GST_EVENT_IS_STICKY (event);
5355   event_type = GST_EVENT_TYPE (event);
5356   switch (event_type) {
5357     case GST_EVENT_FLUSH_START:
5358       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad,
5359           "have event type %d (FLUSH_START)", GST_EVENT_TYPE (event));
5360
5361       /* can't even accept a flush begin event when flushing */
5362       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
5363         goto flushing;
5364
5365       GST_PAD_SET_FLUSHING (pad);
5366       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad, "set flush flag");
5367       break;
5368     case GST_EVENT_FLUSH_STOP:
5369       /* we can't accept flush-stop on inactive pads else the flushing flag
5370        * would be cleared and it would look like the pad can accept data.
5371        * Also, some elements restart a streaming thread in flush-stop which we
5372        * can't allow on inactive pads */
5373       if (G_UNLIKELY (!GST_PAD_IS_ACTIVE (pad)))
5374         goto inactive;
5375
5376       GST_PAD_UNSET_FLUSHING (pad);
5377       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad, "cleared flush flag");
5378       /* Remove pending EOS events */
5379       GST_LOG_OBJECT (pad, "Removing pending EOS and SEGMENT events");
5380       remove_event_by_type (pad, GST_EVENT_EOS);
5381       remove_event_by_type (pad, GST_EVENT_SEGMENT);
5382       GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_EOS);
5383       pad->ABI.abi.last_flowret = GST_FLOW_OK;
5384
5385       GST_OBJECT_UNLOCK (pad);
5386       /* grab stream lock */
5387       GST_PAD_STREAM_LOCK (pad);
5388       need_unlock = TRUE;
5389       GST_OBJECT_LOCK (pad);
5390       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
5391         goto flushing;
5392       break;
5393     case GST_EVENT_RECONFIGURE:
5394       if (GST_PAD_IS_SRC (pad))
5395         GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE);
5396     default:
5397       GST_CAT_DEBUG_OBJECT (GST_CAT_EVENT, pad,
5398           "have event type %" GST_PTR_FORMAT, event);
5399
5400       if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
5401         goto flushing;
5402
5403       switch (event_type) {
5404         case GST_EVENT_STREAM_START:
5405           /* Remove sticky EOS events */
5406           GST_LOG_OBJECT (pad, "Removing pending EOS events");
5407           remove_event_by_type (pad, GST_EVENT_EOS);
5408           GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_EOS);
5409           break;
5410         default:
5411           break;
5412       }
5413
5414       if (serialized) {
5415         if (G_UNLIKELY (GST_PAD_IS_EOS (pad)))
5416           goto eos;
5417
5418         /* lock order: STREAM_LOCK, LOCK, recheck flushing. */
5419         GST_OBJECT_UNLOCK (pad);
5420         GST_PAD_STREAM_LOCK (pad);
5421         need_unlock = TRUE;
5422         GST_OBJECT_LOCK (pad);
5423         if (G_UNLIKELY (GST_PAD_IS_FLUSHING (pad)))
5424           goto flushing;
5425
5426         if (G_UNLIKELY (GST_PAD_IS_EOS (pad)))
5427           goto eos;
5428       }
5429       break;
5430   }
5431
5432   /* now do the probe */
5433   PROBE_PUSH (pad,
5434       type | GST_PAD_PROBE_TYPE_PUSH |
5435       GST_PAD_PROBE_TYPE_BLOCK, event, probe_stopped);
5436
5437   PROBE_PUSH (pad, type | GST_PAD_PROBE_TYPE_PUSH, event, probe_stopped);
5438
5439   if (G_UNLIKELY ((eventfunc = GST_PAD_EVENTFUNC (pad)) == NULL))
5440     goto no_function;
5441
5442   ACQUIRE_PARENT (pad, parent, no_parent);
5443   GST_OBJECT_UNLOCK (pad);
5444
5445   ret = pre_eventfunc_check (pad, event);
5446   if (G_UNLIKELY (ret != GST_FLOW_OK))
5447     goto precheck_failed;
5448
5449   if (sticky)
5450     gst_event_ref (event);
5451
5452   if (eventfunc (pad, parent, event)) {
5453     ret = GST_FLOW_OK;
5454   } else {
5455     /* something went wrong */
5456     switch (event_type) {
5457       case GST_EVENT_CAPS:
5458         ret = GST_FLOW_NOT_NEGOTIATED;
5459         break;
5460       default:
5461         ret = GST_FLOW_ERROR;
5462         break;
5463     }
5464   }
5465   RELEASE_PARENT (parent);
5466
5467   GST_DEBUG_OBJECT (pad, "sent event, ret %s", gst_flow_get_name (ret));
5468
5469   if (sticky) {
5470     if (ret == GST_FLOW_OK) {
5471       GST_OBJECT_LOCK (pad);
5472       /* after the event function accepted the event, we can store the sticky
5473        * event on the pad */
5474       switch (store_sticky_event (pad, event)) {
5475         case GST_FLOW_FLUSHING:
5476           goto flushing;
5477         case GST_FLOW_EOS:
5478           goto eos;
5479         default:
5480           break;
5481       }
5482       GST_OBJECT_UNLOCK (pad);
5483     }
5484     gst_event_unref (event);
5485   }
5486
5487   if (need_unlock)
5488     GST_PAD_STREAM_UNLOCK (pad);
5489
5490   return ret;
5491
5492   /* ERROR handling */
5493 flushing:
5494   {
5495     GST_OBJECT_UNLOCK (pad);
5496     if (need_unlock)
5497       GST_PAD_STREAM_UNLOCK (pad);
5498     GST_CAT_INFO_OBJECT (GST_CAT_EVENT, pad,
5499         "Received event on flushing pad. Discarding");
5500     gst_event_unref (event);
5501     return GST_FLOW_FLUSHING;
5502   }
5503 inactive:
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 flush-stop on inactive pad. Discarding");
5510     gst_event_unref (event);
5511     return GST_FLOW_FLUSHING;
5512   }
5513 eos:
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 event on EOS pad. Discarding");
5520     gst_event_unref (event);
5521     return GST_FLOW_EOS;
5522   }
5523 probe_stopped:
5524   {
5525     GST_OBJECT_UNLOCK (pad);
5526     if (need_unlock)
5527       GST_PAD_STREAM_UNLOCK (pad);
5528     /* Only unref if unhandled */
5529     if (ret != GST_FLOW_CUSTOM_SUCCESS_1)
5530       gst_event_unref (event);
5531
5532     switch (ret) {
5533       case GST_FLOW_CUSTOM_SUCCESS_1:
5534       case GST_FLOW_CUSTOM_SUCCESS:
5535         GST_DEBUG_OBJECT (pad, "dropped or handled event");
5536         ret = GST_FLOW_OK;
5537         break;
5538       default:
5539         GST_DEBUG_OBJECT (pad, "an error occurred %s", gst_flow_get_name (ret));
5540         break;
5541     }
5542     return ret;
5543   }
5544 no_function:
5545   {
5546     g_warning ("pad %s:%s has no event handler, file a bug.",
5547         GST_DEBUG_PAD_NAME (pad));
5548     GST_OBJECT_UNLOCK (pad);
5549     if (need_unlock)
5550       GST_PAD_STREAM_UNLOCK (pad);
5551     gst_event_unref (event);
5552     return GST_FLOW_NOT_SUPPORTED;
5553   }
5554 no_parent:
5555   {
5556     GST_DEBUG_OBJECT (pad, "no parent");
5557     GST_OBJECT_UNLOCK (pad);
5558     if (need_unlock)
5559       GST_PAD_STREAM_UNLOCK (pad);
5560     gst_event_unref (event);
5561     return GST_FLOW_FLUSHING;
5562   }
5563 precheck_failed:
5564   {
5565     GST_DEBUG_OBJECT (pad, "pre event check failed");
5566     RELEASE_PARENT (parent);
5567     if (need_unlock)
5568       GST_PAD_STREAM_UNLOCK (pad);
5569     gst_event_unref (event);
5570     return ret;
5571   }
5572 }
5573
5574 /**
5575  * gst_pad_send_event:
5576  * @pad: a #GstPad to send the event to.
5577  * @event: (transfer full): the #GstEvent to send to the pad.
5578  *
5579  * Sends the event to the pad. This function can be used
5580  * by applications to send events in the pipeline.
5581  *
5582  * If @pad is a source pad, @event should be an upstream event. If @pad is a
5583  * sink pad, @event should be a downstream event. For example, you would not
5584  * send a #GST_EVENT_EOS on a src pad; EOS events only propagate downstream.
5585  * Furthermore, some downstream events have to be serialized with data flow,
5586  * like EOS, while some can travel out-of-band, like #GST_EVENT_FLUSH_START. If
5587  * the event needs to be serialized with data flow, this function will take the
5588  * pad's stream lock while calling its event function.
5589  *
5590  * To find out whether an event type is upstream, downstream, or downstream and
5591  * serialized, see #GstEventTypeFlags, gst_event_type_get_flags(),
5592  * #GST_EVENT_IS_UPSTREAM, #GST_EVENT_IS_DOWNSTREAM, and
5593  * #GST_EVENT_IS_SERIALIZED. Note that in practice that an application or
5594  * plugin doesn't need to bother itself with this information; the core handles
5595  * all necessary locks and checks.
5596  *
5597  * This function takes ownership of the provided event so you should
5598  * gst_event_ref() it if you want to reuse the event after this call.
5599  *
5600  * Returns: %TRUE if the event was handled.
5601  */
5602 gboolean
5603 gst_pad_send_event (GstPad * pad, GstEvent * event)
5604 {
5605   gboolean result;
5606   GstPadProbeType type;
5607
5608   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5609   g_return_val_if_fail (event != NULL, FALSE);
5610
5611   if (GST_PAD_IS_SINK (pad)) {
5612     if (G_UNLIKELY (!GST_EVENT_IS_DOWNSTREAM (event)))
5613       goto wrong_direction;
5614     type = GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM;
5615   } else if (GST_PAD_IS_SRC (pad)) {
5616     if (G_UNLIKELY (!GST_EVENT_IS_UPSTREAM (event)))
5617       goto wrong_direction;
5618     type = GST_PAD_PROBE_TYPE_EVENT_UPSTREAM;
5619   } else
5620     goto unknown_direction;
5621
5622   if (gst_pad_send_event_unchecked (pad, event, type) != GST_FLOW_OK)
5623     result = FALSE;
5624   else
5625     result = TRUE;
5626
5627   return result;
5628
5629   /* ERROR handling */
5630 wrong_direction:
5631   {
5632     g_warning ("pad %s:%s sending %s event in wrong direction",
5633         GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE_NAME (event));
5634     gst_event_unref (event);
5635     return FALSE;
5636   }
5637 unknown_direction:
5638   {
5639     g_warning ("pad %s:%s has invalid direction", GST_DEBUG_PAD_NAME (pad));
5640     gst_event_unref (event);
5641     return FALSE;
5642   }
5643 }
5644
5645 /**
5646  * gst_pad_set_element_private:
5647  * @pad: the #GstPad to set the private data of.
5648  * @priv: The private data to attach to the pad.
5649  *
5650  * Set the given private data gpointer on the pad.
5651  * This function can only be used by the element that owns the pad.
5652  * No locking is performed in this function.
5653  */
5654 void
5655 gst_pad_set_element_private (GstPad * pad, gpointer priv)
5656 {
5657   pad->element_private = priv;
5658 }
5659
5660 /**
5661  * gst_pad_get_element_private:
5662  * @pad: the #GstPad to get the private data of.
5663  *
5664  * Gets the private data of a pad.
5665  * No locking is performed in this function.
5666  *
5667  * Returns: (transfer none): a #gpointer to the private data.
5668  */
5669 gpointer
5670 gst_pad_get_element_private (GstPad * pad)
5671 {
5672   return pad->element_private;
5673 }
5674
5675 /**
5676  * gst_pad_get_sticky_event:
5677  * @pad: the #GstPad to get the event from.
5678  * @event_type: the #GstEventType that should be retrieved.
5679  * @idx: the index of the event
5680  *
5681  * Returns a new reference of the sticky event of type @event_type
5682  * from the event.
5683  *
5684  * Returns: (transfer full) (nullable): a #GstEvent of type
5685  * @event_type or %NULL when no event of @event_type was on
5686  * @pad. Unref after usage.
5687  */
5688 GstEvent *
5689 gst_pad_get_sticky_event (GstPad * pad, GstEventType event_type, guint idx)
5690 {
5691   GstEvent *event = NULL;
5692   PadEvent *ev;
5693
5694   g_return_val_if_fail (GST_IS_PAD (pad), NULL);
5695   g_return_val_if_fail ((event_type & GST_EVENT_TYPE_STICKY) != 0, NULL);
5696
5697   GST_OBJECT_LOCK (pad);
5698   ev = find_event_by_type (pad, event_type, idx);
5699   if (ev && (event = ev->event))
5700     gst_event_ref (event);
5701   GST_OBJECT_UNLOCK (pad);
5702
5703   return event;
5704 }
5705
5706 typedef struct
5707 {
5708   GstPadStickyEventsForeachFunction func;
5709   gpointer user_data;
5710 } ForeachDispatch;
5711
5712 static gboolean
5713 foreach_dispatch_function (GstPad * pad, PadEvent * ev, gpointer user_data)
5714 {
5715   ForeachDispatch *data = user_data;
5716   gboolean ret = TRUE;
5717
5718   if (ev->event) {
5719     GST_OBJECT_UNLOCK (pad);
5720
5721     ret = data->func (pad, &ev->event, data->user_data);
5722
5723     GST_OBJECT_LOCK (pad);
5724   }
5725
5726   return ret;
5727 }
5728
5729 /**
5730  * gst_pad_sticky_events_foreach:
5731  * @pad: the #GstPad that should be used for iteration.
5732  * @foreach_func: (scope call): the #GstPadStickyEventsForeachFunction that
5733  *                should be called for every event.
5734  * @user_data: (closure): the optional user data.
5735  *
5736  * Iterates all sticky events on @pad and calls @foreach_func for every
5737  * event. If @foreach_func returns %FALSE the iteration is immediately stopped.
5738  */
5739 void
5740 gst_pad_sticky_events_foreach (GstPad * pad,
5741     GstPadStickyEventsForeachFunction foreach_func, gpointer user_data)
5742 {
5743   ForeachDispatch data;
5744
5745   g_return_if_fail (GST_IS_PAD (pad));
5746   g_return_if_fail (foreach_func != NULL);
5747
5748   data.func = foreach_func;
5749   data.user_data = user_data;
5750
5751   GST_OBJECT_LOCK (pad);
5752   events_foreach (pad, foreach_dispatch_function, &data);
5753   GST_OBJECT_UNLOCK (pad);
5754 }
5755
5756 static void
5757 do_stream_status (GstPad * pad, GstStreamStatusType type,
5758     GThread * thread, GstTask * task)
5759 {
5760   GstElement *parent;
5761
5762   GST_DEBUG_OBJECT (pad, "doing stream-status %d", type);
5763
5764   if ((parent = GST_ELEMENT_CAST (gst_pad_get_parent (pad)))) {
5765     if (GST_IS_ELEMENT (parent)) {
5766       GstMessage *message;
5767       GValue value = { 0 };
5768
5769       if (type == GST_STREAM_STATUS_TYPE_ENTER) {
5770         gchar *tname, *ename, *pname;
5771
5772         /* create a good task name */
5773         ename = gst_element_get_name (parent);
5774         pname = gst_pad_get_name (pad);
5775         tname = g_strdup_printf ("%s:%s", ename, pname);
5776         g_free (ename);
5777         g_free (pname);
5778
5779         gst_object_set_name (GST_OBJECT_CAST (task), tname);
5780         g_free (tname);
5781       }
5782
5783       message = gst_message_new_stream_status (GST_OBJECT_CAST (pad),
5784           type, parent);
5785
5786       g_value_init (&value, GST_TYPE_TASK);
5787       g_value_set_object (&value, task);
5788       gst_message_set_stream_status_object (message, &value);
5789       g_value_unset (&value);
5790
5791       GST_DEBUG_OBJECT (pad, "posting stream-status %d", type);
5792       gst_element_post_message (parent, message);
5793     }
5794     gst_object_unref (parent);
5795   }
5796 }
5797
5798 static void
5799 pad_enter_thread (GstTask * task, GThread * thread, gpointer user_data)
5800 {
5801   do_stream_status (GST_PAD_CAST (user_data), GST_STREAM_STATUS_TYPE_ENTER,
5802       thread, task);
5803 }
5804
5805 static void
5806 pad_leave_thread (GstTask * task, GThread * thread, gpointer user_data)
5807 {
5808   do_stream_status (GST_PAD_CAST (user_data), GST_STREAM_STATUS_TYPE_LEAVE,
5809       thread, task);
5810 }
5811
5812 /**
5813  * gst_pad_start_task:
5814  * @pad: the #GstPad to start the task of
5815  * @func: the task function to call
5816  * @user_data: user data passed to the task function
5817  * @notify: called when @user_data is no longer referenced
5818  *
5819  * Starts a task that repeatedly calls @func with @user_data. This function
5820  * is mostly used in pad activation functions to start the dataflow.
5821  * The #GST_PAD_STREAM_LOCK of @pad will automatically be acquired
5822  * before @func is called.
5823  *
5824  * Returns: a %TRUE if the task could be started.
5825  */
5826 gboolean
5827 gst_pad_start_task (GstPad * pad, GstTaskFunction func, gpointer user_data,
5828     GDestroyNotify notify)
5829 {
5830   GstTask *task;
5831   gboolean res;
5832
5833   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5834   g_return_val_if_fail (func != NULL, FALSE);
5835
5836   GST_DEBUG_OBJECT (pad, "start task");
5837
5838   GST_OBJECT_LOCK (pad);
5839   task = GST_PAD_TASK (pad);
5840   if (task == NULL) {
5841     task = gst_task_new (func, user_data, notify);
5842     gst_task_set_lock (task, GST_PAD_GET_STREAM_LOCK (pad));
5843     gst_task_set_enter_callback (task, pad_enter_thread, pad, NULL);
5844     gst_task_set_leave_callback (task, pad_leave_thread, pad, NULL);
5845     GST_INFO_OBJECT (pad, "created task %p", task);
5846     GST_PAD_TASK (pad) = task;
5847     gst_object_ref (task);
5848     /* release lock to post the message */
5849     GST_OBJECT_UNLOCK (pad);
5850
5851     do_stream_status (pad, GST_STREAM_STATUS_TYPE_CREATE, NULL, task);
5852
5853     gst_object_unref (task);
5854
5855     GST_OBJECT_LOCK (pad);
5856     /* nobody else is supposed to have changed the pad now */
5857     if (GST_PAD_TASK (pad) != task)
5858       goto concurrent_stop;
5859   }
5860   res = gst_task_set_state (task, GST_TASK_STARTED);
5861   GST_OBJECT_UNLOCK (pad);
5862
5863   return res;
5864
5865   /* ERRORS */
5866 concurrent_stop:
5867   {
5868     GST_OBJECT_UNLOCK (pad);
5869     return TRUE;
5870   }
5871 }
5872
5873 /**
5874  * gst_pad_pause_task:
5875  * @pad: the #GstPad to pause the task of
5876  *
5877  * Pause the task of @pad. This function will also wait until the
5878  * function executed by the task is finished if this function is not
5879  * called from the task function.
5880  *
5881  * Returns: a %TRUE if the task could be paused or %FALSE when the pad
5882  * has no task.
5883  */
5884 gboolean
5885 gst_pad_pause_task (GstPad * pad)
5886 {
5887   GstTask *task;
5888   gboolean res;
5889
5890   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5891
5892   GST_DEBUG_OBJECT (pad, "pause task");
5893
5894   GST_OBJECT_LOCK (pad);
5895   task = GST_PAD_TASK (pad);
5896   if (task == NULL)
5897     goto no_task;
5898   res = gst_task_set_state (task, GST_TASK_PAUSED);
5899   GST_OBJECT_UNLOCK (pad);
5900
5901   /* wait for task function to finish, this lock is recursive so it does nothing
5902    * when the pause is called from the task itself */
5903   GST_PAD_STREAM_LOCK (pad);
5904   GST_PAD_STREAM_UNLOCK (pad);
5905
5906   return res;
5907
5908 no_task:
5909   {
5910     GST_DEBUG_OBJECT (pad, "pad has no task");
5911     GST_OBJECT_UNLOCK (pad);
5912     return FALSE;
5913   }
5914 }
5915
5916 /**
5917  * gst_pad_stop_task:
5918  * @pad: the #GstPad to stop the task of
5919  *
5920  * Stop the task of @pad. This function will also make sure that the
5921  * function executed by the task will effectively stop if not called
5922  * from the GstTaskFunction.
5923  *
5924  * This function will deadlock if called from the GstTaskFunction of
5925  * the task. Use gst_task_pause() instead.
5926  *
5927  * Regardless of whether the pad has a task, the stream lock is acquired and
5928  * released so as to ensure that streaming through this pad has finished.
5929  *
5930  * Returns: a %TRUE if the task could be stopped or %FALSE on error.
5931  */
5932 gboolean
5933 gst_pad_stop_task (GstPad * pad)
5934 {
5935   GstTask *task;
5936   gboolean res;
5937
5938   g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
5939
5940   GST_DEBUG_OBJECT (pad, "stop task");
5941
5942   GST_OBJECT_LOCK (pad);
5943   task = GST_PAD_TASK (pad);
5944   if (task == NULL)
5945     goto no_task;
5946   GST_PAD_TASK (pad) = NULL;
5947   res = gst_task_set_state (task, GST_TASK_STOPPED);
5948   GST_OBJECT_UNLOCK (pad);
5949
5950   GST_PAD_STREAM_LOCK (pad);
5951   GST_PAD_STREAM_UNLOCK (pad);
5952
5953   if (!gst_task_join (task))
5954     goto join_failed;
5955
5956   gst_object_unref (task);
5957
5958   return res;
5959
5960 no_task:
5961   {
5962     GST_DEBUG_OBJECT (pad, "no task");
5963     GST_OBJECT_UNLOCK (pad);
5964
5965     GST_PAD_STREAM_LOCK (pad);
5966     GST_PAD_STREAM_UNLOCK (pad);
5967
5968     /* this is not an error */
5969     return TRUE;
5970   }
5971 join_failed:
5972   {
5973     /* this is bad, possibly the application tried to join the task from
5974      * the task's thread. We install the task again so that it will be stopped
5975      * again from the right thread next time hopefully. */
5976     GST_OBJECT_LOCK (pad);
5977     GST_DEBUG_OBJECT (pad, "join failed");
5978     /* we can only install this task if there was no other task */
5979     if (GST_PAD_TASK (pad) == NULL)
5980       GST_PAD_TASK (pad) = task;
5981     GST_OBJECT_UNLOCK (pad);
5982
5983     return FALSE;
5984   }
5985 }
5986
5987 /**
5988  * gst_pad_probe_info_get_event:
5989  * @info: a #GstPadProbeInfo
5990  *
5991  * Returns: (transfer none): The #GstEvent from the probe
5992  */
5993
5994 GstEvent *
5995 gst_pad_probe_info_get_event (GstPadProbeInfo * info)
5996 {
5997   g_return_val_if_fail (info->type & (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM |
5998           GST_PAD_PROBE_TYPE_EVENT_UPSTREAM), NULL);
5999
6000   return GST_PAD_PROBE_INFO_EVENT (info);
6001 }
6002
6003
6004 /**
6005  * gst_pad_probe_info_get_query:
6006  * @info: a #GstPadProbeInfo
6007  *
6008  * Returns: (transfer none): The #GstQuery from the probe
6009  */
6010
6011 GstQuery *
6012 gst_pad_probe_info_get_query (GstPadProbeInfo * info)
6013 {
6014   g_return_val_if_fail (info->type & (GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM |
6015           GST_PAD_PROBE_TYPE_QUERY_UPSTREAM), NULL);
6016
6017   return GST_PAD_PROBE_INFO_QUERY (info);
6018 }
6019
6020 /**
6021  * gst_pad_probe_info_get_buffer:
6022  * @info: a #GstPadProbeInfo
6023  *
6024  * Returns: (transfer none): The #GstBuffer from the probe
6025  */
6026
6027 GstBuffer *
6028 gst_pad_probe_info_get_buffer (GstPadProbeInfo * info)
6029 {
6030   g_return_val_if_fail (info->type & GST_PAD_PROBE_TYPE_BUFFER, NULL);
6031
6032   return GST_PAD_PROBE_INFO_BUFFER (info);
6033 }
6034
6035 /**
6036  * gst_pad_probe_info_get_bufferlist:
6037  * @info: a #GstPadProbeInfo
6038  *
6039  * Returns: (transfer none): The #GstBufferlist from the probe
6040  */
6041
6042 GstBufferList *
6043 gst_pad_probe_info_get_buffer_list (GstPadProbeInfo * info)
6044 {
6045   g_return_val_if_fail (info->type & GST_PAD_PROBE_TYPE_BUFFER_LIST, NULL);
6046
6047   return GST_PAD_PROBE_INFO_BUFFER_LIST (info);
6048 }
6049
6050 /**
6051  * gst_pad_get_last_flow_return:
6052  * @pad: the #GstPad
6053  *
6054  * Gets the #GstFlowReturn return from the last data passed by this pad.
6055  *
6056  * Since: 1.4
6057  */
6058 GstFlowReturn
6059 gst_pad_get_last_flow_return (GstPad * pad)
6060 {
6061   GstFlowReturn ret;
6062
6063   GST_OBJECT_LOCK (pad);
6064   ret = GST_PAD_LAST_FLOW_RETURN (pad);
6065   GST_OBJECT_UNLOCK (pad);
6066
6067   return ret;
6068 }