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