gst/gstpad.h

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wim.taymans@chello.be>
   4  *
   5  * gstpad.h: Header for GstPad object
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23
  24 #ifndef __GST_PAD_H__
  25 #define __GST_PAD_H__
  26
  27 #include <gst/gstconfig.h>
  28
  29 typedef struct _GstPad GstPad;
  30 typedef struct _GstPadPrivate GstPadPrivate;
  31 typedef struct _GstPadClass GstPadClass;
  32
  33 /**
  34  * GstPadDirection:
  35  * @GST_PAD_UNKNOWN: direction is unknown.
  36  * @GST_PAD_SRC: the pad is a source pad.
  37  * @GST_PAD_SINK: the pad is a sink pad.
  38  *
  39  * The direction of a pad.
  40  */
  41 typedef enum {
  42   GST_PAD_UNKNOWN,
  43   GST_PAD_SRC,
  44   GST_PAD_SINK
  45 } GstPadDirection;
  46
  47 /**
  48  * GstPadMode:
  49  * @GST_PAD_MODE_NONE: Pad will not handle dataflow
  50  * @GST_PAD_MODE_PUSH: Pad handles dataflow in downstream push mode
  51  * @GST_PAD_MODE_PULL: Pad handles dataflow in upstream pull mode
  52  *
  53  * The status of a GstPad. After activating a pad, which usually happens when the
  54  * parent element goes from READY to PAUSED, the GstPadMode defines if the
  55  * pad operates in push or pull mode.
  56  */
  57 typedef enum {
  58   GST_PAD_MODE_NONE,
  59   GST_PAD_MODE_PUSH,
  60   GST_PAD_MODE_PULL
  61 } GstPadMode;
  62
  63 #include <gst/gstobject.h>
  64 #include <gst/gstbuffer.h>
  65 #include <gst/gstbufferlist.h>
  66 #include <gst/gstcaps.h>
  67 #include <gst/gstpadtemplate.h>
  68 #include <gst/gstevent.h>
  69 #include <gst/gstquery.h>
  70 #include <gst/gsttask.h>
  71
  72 G_BEGIN_DECLS
  73
  74 /*
  75  * Pad base class
  76  */
  77 #define GST_TYPE_PAD                    (gst_pad_get_type ())
  78 #define GST_IS_PAD(obj)                 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_PAD))
  79 #define GST_IS_PAD_CLASS(klass)         (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_PAD))
  80 #define GST_PAD(obj)                    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_PAD, GstPad))
  81 #define GST_PAD_CLASS(klass)            (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_PAD, GstPadClass))
  82 #define GST_PAD_CAST(obj)               ((GstPad*)(obj))
  83
  84
  85
  86 /**
  87  * GstPadLinkReturn:
  88  * @GST_PAD_LINK_OK             : link succeeded
  89  * @GST_PAD_LINK_WRONG_HIERARCHY: pads have no common grandparent
  90  * @GST_PAD_LINK_WAS_LINKED     : pad was already linked
  91  * @GST_PAD_LINK_WRONG_DIRECTION: pads have wrong direction
  92  * @GST_PAD_LINK_NOFORMAT       : pads do not have common format
  93  * @GST_PAD_LINK_NOSCHED        : pads cannot cooperate in scheduling
  94  * @GST_PAD_LINK_REFUSED        : refused for some reason
  95  *
  96  * Result values from gst_pad_link and friends.
  97  */
  98 typedef enum {
  99   GST_PAD_LINK_OK               =  0,
 100   GST_PAD_LINK_WRONG_HIERARCHY  = -1,
 101   GST_PAD_LINK_WAS_LINKED       = -2,
 102   GST_PAD_LINK_WRONG_DIRECTION  = -3,
 103   GST_PAD_LINK_NOFORMAT         = -4,
 104   GST_PAD_LINK_NOSCHED          = -5,
 105   GST_PAD_LINK_REFUSED          = -6
 106 } GstPadLinkReturn;
 107
 108 /**
 109  * GST_PAD_LINK_FAILED:
 110  * @ret: the #GstPadLinkReturn value
 111  *
 112  * Macro to test if the given #GstPadLinkReturn value indicates a failed
 113  * link step.
 114  */
 115 #define GST_PAD_LINK_FAILED(ret) ((ret) < GST_PAD_LINK_OK)
 116
 117 /**
 118  * GST_PAD_LINK_SUCCESSFUL:
 119  * @ret: the #GstPadLinkReturn value
 120  *
 121  * Macro to test if the given #GstPadLinkReturn value indicates a successful
 122  * link step.
 123  */
 124 #define GST_PAD_LINK_SUCCESSFUL(ret) ((ret) >= GST_PAD_LINK_OK)
 125
 126 /**
 127  * GstFlowReturn:
 128  * @GST_FLOW_OK:                 Data passing was ok.
 129  * @GST_FLOW_NOT_LINKED:         Pad is not linked.
 130  * @GST_FLOW_WRONG_STATE:        Pad is in wrong state.
 131  * @GST_FLOW_EOS:                Pad is EOS.
 132  * @GST_FLOW_NOT_NEGOTIATED:     Pad is not negotiated.
 133  * @GST_FLOW_ERROR:              Some (fatal) error occured. Element generating
 134  *                               this error should post an error message with more
 135  *                               details.
 136  * @GST_FLOW_NOT_SUPPORTED:      This operation is not supported.
 137  * @GST_FLOW_CUSTOM_SUCCESS:     Elements can use values starting from
 138  *                               this (and higher) to define custom success
 139  *                               codes. Since 0.10.7.
 140  * @GST_FLOW_CUSTOM_SUCCESS_1:   Pre-defined custom success code (define your
 141  *                               custom success code to this to avoid compiler
 142  *                               warnings). Since 0.10.29.
 143  * @GST_FLOW_CUSTOM_SUCCESS_2:   Pre-defined custom success code. Since 0.10.29.
 144  * @GST_FLOW_CUSTOM_ERROR:       Elements can use values starting from
 145  *                               this (and lower) to define custom error codes.
 146  *                               Since 0.10.7.
 147  * @GST_FLOW_CUSTOM_ERROR_1:     Pre-defined custom error code (define your
 148  *                               custom error code to this to avoid compiler
 149  *                               warnings). Since 0.10.29.
 150  * @GST_FLOW_CUSTOM_ERROR_2:     Pre-defined custom error code. Since 0.10.29.
 151  *
 152  * The result of passing data to a pad.
 153  *
 154  * Note that the custom return values should not be exposed outside of the
 155  * element scope and are available since 0.10.7.
 156  */
 157 /* FIXME 0.11: remove custom flow returns */
 158 typedef enum {
 159   /* custom success starts here */
 160   GST_FLOW_CUSTOM_SUCCESS_2 = 102,
 161   GST_FLOW_CUSTOM_SUCCESS_1 = 101,
 162   GST_FLOW_CUSTOM_SUCCESS = 100,
 163
 164   /* core predefined */
 165   GST_FLOW_OK             =  0,
 166   /* expected failures */
 167   GST_FLOW_NOT_LINKED     = -1,
 168   GST_FLOW_WRONG_STATE    = -2,
 169   /* error cases */
 170   GST_FLOW_EOS            = -3,
 171   GST_FLOW_NOT_NEGOTIATED = -4,
 172   GST_FLOW_ERROR          = -5,
 173   GST_FLOW_NOT_SUPPORTED  = -6,
 174
 175   /* custom error starts here */
 176   GST_FLOW_CUSTOM_ERROR   = -100,
 177   GST_FLOW_CUSTOM_ERROR_1 = -101,
 178   GST_FLOW_CUSTOM_ERROR_2 = -102
 179 } GstFlowReturn;
 180
 181 const gchar*            gst_flow_get_name       (GstFlowReturn ret);
 182 GQuark                  gst_flow_to_quark       (GstFlowReturn ret);
 183
 184 /**
 185  * GstPadLinkCheck:
 186  * @GST_PAD_LINK_CHECK_NOTHING: Don't check hierarchy or caps compatibility.
 187  * @GST_PAD_LINK_CHECK_HIERARCHY: Check the pads have same parents/grandparents.
 188  *   Could be omitted if it is already known that the two elements that own the
 189  *   pads are in the same bin.
 190  * @GST_PAD_LINK_CHECK_TEMPLATE_CAPS: Check if the pads are compatible by using
 191  *   their template caps. This is much faster than @GST_PAD_LINK_CHECK_CAPS, but
 192  *   would be unsafe e.g. if one pad has %GST_CAPS_ANY.
 193  * @GST_PAD_LINK_CHECK_CAPS: Check if the pads are compatible by comparing the
 194  *   caps returned by gst_pad_query_caps().
 195  *
 196  * The amount of checking to be done when linking pads. @GST_PAD_LINK_CHECK_CAPS
 197  * and @GST_PAD_LINK_CHECK_TEMPLATE_CAPS are mutually exclusive. If both are
 198  * specified, expensive but safe @GST_PAD_LINK_CHECK_CAPS are performed.
 199  *
 200  * <warning><para>
 201  * Only disable some of the checks if you are 100% certain you know the link
 202  * will not fail because of hierarchy/caps compatibility failures. If uncertain,
 203  * use the default checks (%GST_PAD_LINK_CHECK_DEFAULT) or the regular methods
 204  * for linking the pads.
 205  * </para></warning>
 206  *
 207  * Since: 0.10.30
 208  */
 209
 210 typedef enum {
 211   GST_PAD_LINK_CHECK_NOTHING       = 0,
 212   GST_PAD_LINK_CHECK_HIERARCHY     = 1 << 0,
 213   GST_PAD_LINK_CHECK_TEMPLATE_CAPS = 1 << 1,
 214   GST_PAD_LINK_CHECK_CAPS          = 1 << 2
 215 } GstPadLinkCheck;
 216
 217 /**
 218  * GST_PAD_LINK_CHECK_DEFAULT:
 219  *
 220  * The default checks done when linking pads (i.e. the ones used by
 221  * gst_pad_link()).
 222  *
 223  * Since: 0.10.30
 224  */
 225 #define GST_PAD_LINK_CHECK_DEFAULT ((GstPadLinkCheck) (GST_PAD_LINK_CHECK_HIERARCHY | GST_PAD_LINK_CHECK_CAPS))
 226
 227 /* pad states */
 228 /**
 229  * GstPadActivateFunction:
 230  * @pad: a #GstPad
 231  * @parent: the parent of @pad
 232  *
 233  * This function is called when the pad is activated during the element
 234  * READY to PAUSED state change. By default this function will call the
 235  * activate function that puts the pad in push mode but elements can
 236  * override this function to activate the pad in pull mode if they wish.
 237  *
 238  * Returns: TRUE if the pad could be activated.
 239  */
 240 typedef gboolean                (*GstPadActivateFunction)       (GstPad *pad, GstObject *parent);
 241 /**
 242  * GstPadActivateModeFunction:
 243  * @pad: a #GstPad
 244  * @parent: the parent of @pad
 245  * @mode: the requested activation mode of @pad
 246  * @active: activate or deactivate the pad.
 247  *
 248  * The prototype of the push and pull activate functions.
 249  *
 250  * Returns: TRUE if the pad could be activated or deactivated.
 251  */
 252 typedef gboolean                (*GstPadActivateModeFunction)   (GstPad *pad, GstObject *parent,
 253                                                                  GstPadMode mode, gboolean active);
 254
 255
 256 /* data passing */
 257 /**
 258  * GstPadChainFunction:
 259  * @pad: the sink #GstPad that performed the chain.
 260  * @parent: the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT flag is set,
 261  *          @parent is guaranteed to be not-NULL and remain valid during the
 262  *          execution of this function.
 263  * @buffer: the #GstBuffer that is chained, not %NULL.
 264  *
 265  * A function that will be called on sinkpads when chaining buffers.
 266  * The function typically processes the data contained in the buffer and
 267  * either consumes the data or passes it on to the internally linked pad(s).
 268  *
 269  * The implementer of this function receives a refcount to @buffer and should
 270  * gst_buffer_unref() when the buffer is no longer needed.
 271  *
 272  * When a chain function detects an error in the data stream, it must post an
 273  * error on the bus and return an appropriate #GstFlowReturn value.
 274  *
 275  * Returns: #GST_FLOW_OK for success
 276  */
 277 typedef GstFlowReturn           (*GstPadChainFunction)          (GstPad *pad, GstObject *parent,
 278                                                                  GstBuffer *buffer);
 279
 280 /**
 281  * GstPadChainListFunction:
 282  * @pad: the sink #GstPad that performed the chain.
 283  * @parent: the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT flag is set,
 284  *          @parent is guaranteed to be not-NULL and remain valid during the
 285  *          execution of this function.
 286  * @list: the #GstBufferList that is chained, not %NULL.
 287  *
 288  * A function that will be called on sinkpads when chaining buffer lists.
 289  * The function typically processes the data contained in the buffer list and
 290  * either consumes the data or passes it on to the internally linked pad(s).
 291  *
 292  * The implementer of this function receives a refcount to @list and
 293  * should gst_buffer_list_unref() when the list is no longer needed.
 294  *
 295  * When a chainlist function detects an error in the data stream, it must
 296  * post an error on the bus and return an appropriate #GstFlowReturn value.
 297  *
 298  * Returns: #GST_FLOW_OK for success
 299  */
 300 typedef GstFlowReturn           (*GstPadChainListFunction)      (GstPad *pad, GstObject *parent,
 301                                                                  GstBufferList *list);
 302
 303 /**
 304  * GstPadGetRangeFunction:
 305  * @pad: the src #GstPad to perform the getrange on.
 306  * @parent: the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT flag is set,
 307  *          @parent is guaranteed to be not-NULL and remain valid during the
 308  *          execution of this function.
 309  * @offset: the offset of the range
 310  * @length: the length of the range
 311  * @buffer: a memory location to hold the result buffer, cannot be NULL.
 312  *
 313  * This function will be called on source pads when a peer element
 314  * request a buffer at the specified @offset and @length. If this function
 315  * returns #GST_FLOW_OK, the result buffer will be stored in @buffer. The
 316  * contents of @buffer is invalid for any other return value.
 317  *
 318  * This function is installed on a source pad with
 319  * gst_pad_set_getrange_function() and can only be called on source pads after
 320  * they are successfully activated with gst_pad_activate_pull().
 321  *
 322  * @offset and @length are always given in byte units. @offset must normally be a value
 323  * between 0 and the length in bytes of the data available on @pad. The
 324  * length (duration in bytes) can be retrieved with a #GST_QUERY_DURATION or with a
 325  * #GST_QUERY_SEEKING.
 326  *
 327  * Any @offset larger or equal than the length will make the function return
 328  * #GST_FLOW_UNEXPECTED, which corresponds to EOS. In this case @buffer does not
 329  * contain a valid buffer.
 330  *
 331  * The buffer size of @buffer will only be smaller than @length when @offset is
 332  * near the end of the stream. In all other cases, the size of @buffer must be
 333  * exactly the requested size.
 334  *
 335  * It is allowed to call this function with a 0 @length and valid @offset, in
 336  * which case @buffer will contain a 0-sized buffer and the function returns
 337  * #GST_FLOW_OK.
 338  *
 339  * When this function is called with a -1 @offset, the sequentially next buffer
 340  * of length @length in the stream is returned.
 341  *
 342  * When this function is called with a -1 @length, a buffer with a default
 343  * optimal length is returned in @buffer. The length might depend on the value
 344  * of @offset.
 345  *
 346  * Returns: #GST_FLOW_OK for success and a valid buffer in @buffer. Any other
 347  * return value leaves @buffer undefined.
 348  */
 349 typedef GstFlowReturn           (*GstPadGetRangeFunction)       (GstPad *pad, GstObject *parent,
 350                                                                  guint64 offset, guint length,
 351                                                                  GstBuffer **buffer);
 352
 353 /**
 354  * GstPadEventFunction:
 355  * @pad: the #GstPad to handle the event.
 356  * @parent: the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT flag is set,
 357  *          @parent is guaranteed to be not-NULL and remain valid during the
 358  *          execution of this function.
 359  * @event: the #GstEvent to handle.
 360  *
 361  * Function signature to handle an event for the pad.
 362  *
 363  * Returns: TRUE if the pad could handle the event.
 364  */
 365 typedef gboolean                (*GstPadEventFunction)          (GstPad *pad, GstObject *parent,
 366                                                                  GstEvent *event);
 367
 368
 369 /* internal links */
 370 /**
 371  * GstPadIterIntLinkFunction:
 372  * @pad: The #GstPad to query.
 373  * @parent: the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT flag is set,
 374  *          @parent is guaranteed to be not-NULL and remain valid during the
 375  *          execution of this function.
 376  *
 377  * The signature of the internal pad link iterator function.
 378  *
 379  * Returns: a new #GstIterator that will iterate over all pads that are
 380  * linked to the given pad on the inside of the parent element.
 381  *
 382  * the caller must call gst_iterator_free() after usage.
 383  *
 384  * Since 0.10.21
 385  */
 386 typedef GstIterator*           (*GstPadIterIntLinkFunction)    (GstPad *pad, GstObject *parent);
 387
 388 /* generic query function */
 389 /**
 390  * GstPadQueryFunction:
 391  * @pad: the #GstPad to query.
 392  * @parent: the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT flag is set,
 393  *          @parent is guaranteed to be not-NULL and remain valid during the
 394  *          execution of this function.
 395  * @query: the #GstQuery object to execute
 396  *
 397  * The signature of the query function.
 398  *
 399  * Returns: TRUE if the query could be performed.
 400  */
 401 typedef gboolean                (*GstPadQueryFunction)          (GstPad *pad, GstObject *parent,
 402                                                                  GstQuery *query);
 403
 404
 405 /* linking */
 406 /**
 407  * GstPadLinkFunction
 408  * @pad: the #GstPad that is linked.
 409  * @peer: the peer #GstPad of the link
 410  *
 411  * Function signature to handle a new link on the pad.
 412  *
 413  * Returns: the result of the link with the specified peer.
 414  */
 415 typedef GstPadLinkReturn        (*GstPadLinkFunction)           (GstPad *pad, GstPad *peer);
 416 /**
 417  * GstPadUnlinkFunction
 418  * @pad: the #GstPad that is linked.
 419  *
 420  * Function signature to handle a unlinking the pad prom its peer.
 421  */
 422 typedef void                    (*GstPadUnlinkFunction)         (GstPad *pad);
 423
 424
 425 /* misc */
 426 /**
 427  * GstPadForwardFunction:
 428  * @pad: the #GstPad that is forwarded.
 429  * @user_data: the gpointer to optional user data.
 430  *
 431  * A forward function is called for all internally linked pads, see
 432  * gst_pad_forward().
 433  *
 434  * Returns: TRUE if the dispatching procedure has to be stopped.
 435  */
 436 typedef gboolean                (*GstPadForwardFunction)        (GstPad *pad, gpointer user_data);
 437
 438 /**
 439  * GstPadProbeType:
 440  * @GST_PAD_PROBE_TYPE_INVALID: invalid probe type
 441  * @GST_PAD_PROBE_TYPE_IDLE: probe idle pads and block
 442  * @GST_PAD_PROBE_TYPE_BLOCK: probe and block pads
 443  * @GST_PAD_PROBE_TYPE_BUFFER: probe buffers
 444  * @GST_PAD_PROBE_TYPE_BUFFER_LIST: probe buffer lists
 445  * @GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM: probe downstream events
 446  * @GST_PAD_PROBE_TYPE_EVENT_UPSTREAM: probe upstream events
 447  * @GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM: probe downstream queries
 448  * @GST_PAD_PROBE_TYPE_QUERY_UPSTREAM: probe upstream queries
 449  * @GST_PAD_PROBE_TYPE_PUSH: probe push
 450  * @GST_PAD_PROBE_TYPE_PULL: probe pull
 451  *
 452  * The different probing types that can occur. When either one of
 453  * @GST_PAD_PROBE_TYPE_IDLE or @GST_PAD_PROBE_TYPE_BLOCK is used, the probe will be a
 454  * blocking probe.
 455  */
 456 typedef enum
 457 {
 458   GST_PAD_PROBE_TYPE_INVALID          = 0,
 459   /* flags to control blocking */
 460   GST_PAD_PROBE_TYPE_IDLE             = (1 << 0),
 461   GST_PAD_PROBE_TYPE_BLOCK            = (1 << 1),
 462   /* flags to select datatypes */
 463   GST_PAD_PROBE_TYPE_BUFFER           = (1 << 4),
 464   GST_PAD_PROBE_TYPE_BUFFER_LIST      = (1 << 5),
 465   GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM = (1 << 6),
 466   GST_PAD_PROBE_TYPE_EVENT_UPSTREAM   = (1 << 7),
 467   GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM = (1 << 8),
 468   GST_PAD_PROBE_TYPE_QUERY_UPSTREAM   = (1 << 9),
 469   /* flags to select scheduling mode */
 470   GST_PAD_PROBE_TYPE_PUSH             = (1 << 12),
 471   GST_PAD_PROBE_TYPE_PULL             = (1 << 13),
 472   /* flag for event probes that want to handle flush events.
 473      The probe can drop flush event which will mean that the rest
 474      of the pipeline will not get flushed */
 475   GST_PAD_PROBE_TYPE_HANDLE_FLUSH     = (1 << 14)
 476 } GstPadProbeType;
 477
 478 #define GST_PAD_PROBE_TYPE_BLOCKING         (GST_PAD_PROBE_TYPE_IDLE | GST_PAD_PROBE_TYPE_BLOCK)
 479 #define GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM (GST_PAD_PROBE_TYPE_BLOCK | GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM)
 480 #define GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM   (GST_PAD_PROBE_TYPE_BLOCK | GST_PAD_PROBE_TYPE_DATA_UPSTREAM)
 481 #define GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM  (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_BUFFER_LIST | \
 482                                              GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM)
 483 #define GST_PAD_PROBE_TYPE_DATA_UPSTREAM    (GST_PAD_PROBE_TYPE_EVENT_UPSTREAM)
 484 #define GST_PAD_PROBE_TYPE_DATA_BOTH        (GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM | \
 485                                              GST_PAD_PROBE_TYPE_DATA_UPSTREAM)
 486 #define GST_PAD_PROBE_TYPE_EVENT_BOTH       (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | \
 487                                              GST_PAD_PROBE_TYPE_EVENT_UPSTREAM)
 488 #define GST_PAD_PROBE_TYPE_QUERY_BOTH       (GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM | \
 489                                              GST_PAD_PROBE_TYPE_QUERY_UPSTREAM)
 490 #define GST_PAD_PROBE_TYPE_ALL_BOTH         (GST_PAD_PROBE_TYPE_DATA_BOTH | \
 491                                              GST_PAD_PROBE_TYPE_QUERY_BOTH)
 492 #define GST_PAD_PROBE_TYPE_SCHEDULING       (GST_PAD_PROBE_TYPE_PUSH | GST_PAD_PROBE_TYPE_PULL)
 493
 494 /**
 495  * GstPadProbeReturn:
 496  * @GST_PAD_PROBE_OK: normal probe return value
 497  * @GST_PAD_PROBE_DROP: drop data in data probes
 498  * @GST_PAD_PROBE_REMOVE: remove probe
 499  * @GST_PAD_PROBE_PASS: pass the data item in the block probe and block on
 500  *                         the next item
 501  *
 502  * Different return values for the #GstPadProbeCallback.
 503  */
 504 typedef enum
 505 {
 506   GST_PAD_PROBE_DROP,
 507   GST_PAD_PROBE_OK,
 508   GST_PAD_PROBE_REMOVE,
 509   GST_PAD_PROBE_PASS,
 510 } GstPadProbeReturn;
 511
 512
 513 /**
 514  * GstPadProbeInfo:
 515  * @type: the current probe type
 516  * @data: type specific data, check the @type field to know the datatype.
 517  *    This field can be NULL.
 518  * @offset: offset of pull probe, this field is valid when @type contains
 519  *    #GST_PAD_PROBE_TYPE_PULL
 520  * @size: size of pull probe, this field is valid when @type contains
 521  *    #GST_PAD_PROBE_TYPE_PULL
 522  *
 523  * Info passed in the #GstPadProbeCallback.
 524  */
 525 typedef struct
 526 {
 527   GstPadProbeType type;
 528   gpointer data;
 529   guint64 offset;
 530   guint size;
 531
 532   gpointer _gst_reserved[GST_PADDING];
 533 } GstPadProbeInfo;
 534
 535 #define GST_PAD_PROBE_INFO_TYPE(d)         ((d)->type)
 536 #define GST_PAD_PROBE_INFO_DATA(d)         ((d)->data)
 537
 538 #define GST_PAD_PROBE_INFO_BUFFER(d)       GST_BUFFER_CAST(GST_PAD_PROBE_INFO_DATA(d))
 539 #define GST_PAD_PROBE_INFO_BUFFER_LIST(d)  GST_BUFFER_LIST_CAST(GST_PAD_PROBE_INFO_DATA(d))
 540 #define GST_PAD_PROBE_INFO_EVENT(d)        GST_EVENT_CAST(GST_PAD_PROBE_INFO_DATA(d))
 541 #define GST_PAD_PROBE_INFO_QUERY(d)        GST_QUERY_CAST(GST_PAD_PROBE_INFO_DATA(d))
 542
 543 #define GST_PAD_PROBE_INFO_OFFSET(d)       ((d)->offset)
 544 #define GST_PAD_PROBE_INFO_SIZE(d)         ((d)->size)
 545
 546 /**
 547  * GstPadProbeCallback
 548  * @pad: the #GstPad that is blocked
 549  * @info: #GstPadProbeInfo
 550  * @user_data: the gpointer to optional user data.
 551  *
 552  * Callback used by gst_pad_add_probe(). Gets called to notify about the current
 553  * blocking type.
 554  *
 555  * The callback is allowed to modify the data pointer in @info.
 556  */
 557 typedef GstPadProbeReturn   (*GstPadProbeCallback)   (GstPad *pad, GstPadProbeInfo *info,
 558                                                       gpointer user_data);
 559
 560 /**
 561  * GstPadStickyEventsForeachFunction:
 562  * @pad: the #GstPad.
 563  * @event: a sticky #GstEvent.
 564  * @user_data: the #gpointer to optional user data.
 565  *
 566  * Callback used by gst_pad_sticky_events_foreach().
 567  *
 568  * When this function returns %TRUE, the next event will be
 569  * returned. When %FALSE is returned, gst_pad_sticky_events_foreach() will return.
 570  *
 571  * When @event is set to NULL, the item will be removed from the list of sticky events.
 572  * When @event has been made writable, the new buffer reference can be assigned
 573  * to @event. This function is responsible for unreffing the old event when
 574  * removing or modifying.
 575  *
 576  * Returns: %TRUE if the iteration should continue
 577  */
 578 typedef gboolean  (*GstPadStickyEventsForeachFunction) (GstPad *pad, GstEvent **event,
 579                                                         gpointer user_data);
 580
 581 /**
 582  * GstPadFlags:
 583  * @GST_PAD_FLAG_BLOCKED: is dataflow on a pad blocked
 584  * @GST_PAD_FLAG_FLUSHING: is pad refusing buffers
 585  * @GST_PAD_FLAG_BLOCKING: is pad currently blocking on a buffer or event
 586  * @GST_PAD_FLAG_NEED_RECONFIGURE: the pad should be reconfigured/renegotiated.
 587  *                            The flag has to be unset manually after
 588  *                            reconfiguration happened.
 589  *                            Since: 0.10.34.
 590  * @GST_PAD_FLAG_PENDING_EVENTS: the pad has pending events
 591  * @GST_PAD_FLAG_FIXED_CAPS: the pad is using fixed caps this means that once the
 592  *                      caps are set on the pad, the caps query function only
 593  *                      returns those caps.
 594  * @GST_PAD_FLAG_PROXY_CAPS: the default event and query handler will forward
 595  *                      all events and queries to the internally linked pads
 596  *                      instead of discarding them.
 597  * @GST_PAD_FLAG_NEED_PARENT: ensure that there is a parent object before calling
 598  *                       into the pad callbacks.
 599  * @GST_PAD_FLAG_LAST: offset to define more flags
 600  *
 601  * Pad state flags
 602  */
 603 typedef enum {
 604   GST_PAD_FLAG_BLOCKED          = (GST_OBJECT_FLAG_LAST << 0),
 605   GST_PAD_FLAG_FLUSHING         = (GST_OBJECT_FLAG_LAST << 1),
 606   GST_PAD_FLAG_BLOCKING         = (GST_OBJECT_FLAG_LAST << 2),
 607   GST_PAD_FLAG_NEED_RECONFIGURE = (GST_OBJECT_FLAG_LAST << 3),
 608   GST_PAD_FLAG_PENDING_EVENTS   = (GST_OBJECT_FLAG_LAST << 4),
 609   GST_PAD_FLAG_FIXED_CAPS       = (GST_OBJECT_FLAG_LAST << 5),
 610   GST_PAD_FLAG_PROXY_CAPS       = (GST_OBJECT_FLAG_LAST << 6),
 611   GST_PAD_FLAG_NEED_PARENT      = (GST_OBJECT_FLAG_LAST << 7),
 612   /* padding */
 613   GST_PAD_FLAG_LAST        = (GST_OBJECT_FLAG_LAST << 16)
 614 } GstPadFlags;
 615
 616 /**
 617  * GstPad:
 618  * @element_private: private data owned by the parent element
 619  * @padtemplate: padtemplate for this pad
 620  * @direction: the direction of the pad, cannot change after creating
 621  *             the pad.
 622  *
 623  * The #GstPad structure. Use the functions to update the variables.
 624  */
 625 struct _GstPad {
 626   GstObject                      object;
 627
 628   /*< public >*/
 629   gpointer                       element_private;
 630
 631   GstPadTemplate                *padtemplate;
 632
 633   GstPadDirection                direction;
 634
 635   /*< private >*/
 636   /* streaming rec_lock */
 637   GStaticRecMutex                stream_rec_lock;
 638   GstTask                       *task;
 639
 640   /* block cond, mutex is from the object */
 641   GCond                         *block_cond;
 642   GHookList                      probes;
 643
 644   GstPadMode                     mode;
 645   GstPadActivateFunction         activatefunc;
 646   GDestroyNotify                 activatenotify;
 647   GstPadActivateModeFunction     activatemodefunc;
 648   GDestroyNotify                 activatemodenotify;
 649
 650   /* pad link */
 651   GstPad                        *peer;
 652   GstPadLinkFunction             linkfunc;
 653   GDestroyNotify                 linknotify;
 654   GstPadUnlinkFunction           unlinkfunc;
 655   GDestroyNotify                 unlinknotify;
 656
 657   /* data transport functions */
 658   GstPadChainFunction            chainfunc;
 659   GDestroyNotify                 chainnotify;
 660   GstPadChainListFunction        chainlistfunc;
 661   GDestroyNotify                 chainlistnotify;
 662   GstPadGetRangeFunction         getrangefunc;
 663   GDestroyNotify                 getrangenotify;
 664   GstPadEventFunction            eventfunc;
 665   GDestroyNotify                 eventnotify;
 666
 667   /* pad offset */
 668   gint64                         offset;
 669
 670   /* generic query method */
 671   GstPadQueryFunction            queryfunc;
 672   GDestroyNotify                 querynotify;
 673
 674   /* internal links */
 675   GstPadIterIntLinkFunction      iterintlinkfunc;
 676   GDestroyNotify                 iterintlinknotify;
 677
 678   /* counts number of probes attached. */
 679   gint                           num_probes;
 680   gint                           num_blocked;
 681
 682   GstPadPrivate                 *priv;
 683
 684   gpointer _gst_reserved[GST_PADDING];
 685 };
 686
 687 struct _GstPadClass {
 688   GstObjectClass        parent_class;
 689
 690   /* signal callbacks */
 691   void          (*linked)               (GstPad *pad, GstPad *peer);
 692   void          (*unlinked)             (GstPad *pad, GstPad *peer);
 693
 694   /*< private >*/
 695   gpointer _gst_reserved[GST_PADDING];
 696 };
 697
 698
 699 /***** helper macros *****/
 700 /* GstPad */
 701 #define GST_PAD_NAME(pad)               (GST_OBJECT_NAME(pad))
 702 #define GST_PAD_PARENT(pad)             (GST_ELEMENT_CAST(GST_OBJECT_PARENT(pad)))
 703 #define GST_PAD_ELEMENT_PRIVATE(pad)    (GST_PAD_CAST(pad)->element_private)
 704 #define GST_PAD_PAD_TEMPLATE(pad)       (GST_PAD_CAST(pad)->padtemplate)
 705 #define GST_PAD_DIRECTION(pad)          (GST_PAD_CAST(pad)->direction)
 706 #define GST_PAD_TASK(pad)               (GST_PAD_CAST(pad)->task)
 707 #define GST_PAD_MODE(pad)               (GST_PAD_CAST(pad)->mode)
 708
 709 #define GST_PAD_ACTIVATEFUNC(pad)       (GST_PAD_CAST(pad)->activatefunc)
 710 #define GST_PAD_ACTIVATEMODEFUNC(pad)   (GST_PAD_CAST(pad)->activatemodefunc)
 711 #define GST_PAD_CHAINFUNC(pad)          (GST_PAD_CAST(pad)->chainfunc)
 712 #define GST_PAD_CHAINLISTFUNC(pad)      (GST_PAD_CAST(pad)->chainlistfunc)
 713 #define GST_PAD_GETRANGEFUNC(pad)       (GST_PAD_CAST(pad)->getrangefunc)
 714 #define GST_PAD_EVENTFUNC(pad)          (GST_PAD_CAST(pad)->eventfunc)
 715 #define GST_PAD_QUERYFUNC(pad)          (GST_PAD_CAST(pad)->queryfunc)
 716 #define GST_PAD_ITERINTLINKFUNC(pad)    (GST_PAD_CAST(pad)->iterintlinkfunc)
 717
 718 #define GST_PAD_PEER(pad)               (GST_PAD_CAST(pad)->peer)
 719 #define GST_PAD_LINKFUNC(pad)           (GST_PAD_CAST(pad)->linkfunc)
 720 #define GST_PAD_UNLINKFUNC(pad)         (GST_PAD_CAST(pad)->unlinkfunc)
 721
 722 #define GST_PAD_IS_SRC(pad)             (GST_PAD_DIRECTION(pad) == GST_PAD_SRC)
 723 #define GST_PAD_IS_SINK(pad)            (GST_PAD_DIRECTION(pad) == GST_PAD_SINK)
 724
 725 #define GST_PAD_IS_LINKED(pad)          (GST_PAD_PEER(pad) != NULL)
 726
 727 #define GST_PAD_IS_ACTIVE(pad)          (GST_PAD_MODE(pad) != GST_PAD_MODE_NONE)
 728
 729 #define GST_PAD_IS_BLOCKED(pad)         (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_BLOCKED))
 730 #define GST_PAD_IS_BLOCKING(pad)        (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_BLOCKING))
 731
 732 #define GST_PAD_IS_FLUSHING(pad)        (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_FLUSHING))
 733 #define GST_PAD_SET_FLUSHING(pad)       (GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_FLUSHING))
 734 #define GST_PAD_UNSET_FLUSHING(pad)     (GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_FLUSHING))
 735
 736 #define GST_PAD_NEEDS_RECONFIGURE(pad)  (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_NEED_RECONFIGURE))
 737 #define GST_PAD_HAS_PENDING_EVENTS(pad) (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_PENDING_EVENTS))
 738 #define GST_PAD_IS_FIXED_CAPS(pad)      (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_FIXED_CAPS))
 739 #define GST_PAD_NEEDS_PARENT(pad)       (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_NEED_PARENT))
 740
 741 #define GST_PAD_IS_PROXY_CAPS(pad)      (GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLAG_PROXY_CAPS))
 742 #define GST_PAD_SET_PROXY_CAPS(pad)     (GST_OBJECT_FLAG_SET (pad, GST_PAD_FLAG_PROXY_CAPS))
 743 #define GST_PAD_UNSET_PROXY_CAPS(pad)   (GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLAG_PROXY_CAPS))
 744
 745 /**
 746  * GST_PAD_GET_STREAM_LOCK:
 747  * @pad: a #GstPad
 748  *
 749  * Get the stream lock of @pad. The stream lock is protecting the
 750  * resources used in the data processing functions of @pad.
 751  */
 752 #define GST_PAD_GET_STREAM_LOCK(pad)    (&(GST_PAD_CAST(pad)->stream_rec_lock))
 753 /**
 754  * GST_PAD_STREAM_LOCK:
 755  * @pad: a #GstPad
 756  *
 757  * Lock the stream lock of @pad.
 758  */
 759 #define GST_PAD_STREAM_LOCK(pad)        (g_static_rec_mutex_lock(GST_PAD_GET_STREAM_LOCK(pad)))
 760 /**
 761  * GST_PAD_STREAM_TRYLOCK:
 762  * @pad: a #GstPad
 763  *
 764  * Try to Lock the stream lock of the pad, return TRUE if the lock could be
 765  * taken.
 766  */
 767 #define GST_PAD_STREAM_TRYLOCK(pad)     (g_static_rec_mutex_trylock(GST_PAD_GET_STREAM_LOCK(pad)))
 768 /**
 769  * GST_PAD_STREAM_UNLOCK:
 770  * @pad: a #GstPad
 771  *
 772  * Unlock the stream lock of @pad.
 773  */
 774 #define GST_PAD_STREAM_UNLOCK(pad)      (g_static_rec_mutex_unlock(GST_PAD_GET_STREAM_LOCK(pad)))
 775
 776 #define GST_PAD_BLOCK_GET_COND(pad)     (GST_PAD_CAST(pad)->block_cond)
 777 #define GST_PAD_BLOCK_WAIT(pad)         (g_cond_wait(GST_PAD_BLOCK_GET_COND (pad), GST_OBJECT_GET_LOCK (pad)))
 778 #define GST_PAD_BLOCK_SIGNAL(pad)       (g_cond_signal(GST_PAD_BLOCK_GET_COND (pad)))
 779 #define GST_PAD_BLOCK_BROADCAST(pad)    (g_cond_broadcast(GST_PAD_BLOCK_GET_COND (pad)))
 780
 781 GType                   gst_pad_get_type                        (void);
 782
 783 /* creating pads */
 784 GstPad*                 gst_pad_new                             (const gchar *name, GstPadDirection direction);
 785 GstPad*                 gst_pad_new_from_template               (GstPadTemplate *templ, const gchar *name);
 786 GstPad*                 gst_pad_new_from_static_template        (GstStaticPadTemplate *templ, const gchar *name);
 787
 788
 789 /**
 790  * gst_pad_get_name:
 791  * @pad: the pad to get the name from
 792  *
 793  * Get a copy of the name of the pad. g_free() after usage.
 794  *
 795  * MT safe.
 796  */
 797 #define gst_pad_get_name(pad) gst_object_get_name (GST_OBJECT_CAST (pad))
 798 /**
 799  * gst_pad_get_parent:
 800  * @pad: the pad to get the parent of
 801  *
 802  * Get the parent of @pad. This function increases the refcount
 803  * of the parent object so you should gst_object_unref() it after usage.
 804  * Can return NULL if the pad did not have a parent.
 805  *
 806  * MT safe.
 807  */
 808 #define gst_pad_get_parent(pad) gst_object_get_parent (GST_OBJECT_CAST (pad))
 809
 810 GstPadDirection         gst_pad_get_direction                   (GstPad *pad);
 811
 812 gboolean                gst_pad_set_active                      (GstPad *pad, gboolean active);
 813 gboolean                gst_pad_is_active                       (GstPad *pad);
 814 gboolean                gst_pad_activate_mode                   (GstPad *pad, GstPadMode mode,
 815                                                                  gboolean active);
 816
 817 gulong                  gst_pad_add_probe                       (GstPad *pad,
 818                                                                  GstPadProbeType mask,
 819                                                                  GstPadProbeCallback callback,
 820                                                                  gpointer user_data,
 821                                                                  GDestroyNotify destroy_data);
 822 void                    gst_pad_remove_probe                    (GstPad *pad, gulong id);
 823
 824 gboolean                gst_pad_is_blocked                      (GstPad *pad);
 825 gboolean                gst_pad_is_blocking                     (GstPad *pad);
 826
 827 void                    gst_pad_mark_reconfigure                (GstPad *pad);
 828 gboolean                gst_pad_check_reconfigure               (GstPad *pad);
 829
 830 void                    gst_pad_set_element_private             (GstPad *pad, gpointer priv);
 831 gpointer                gst_pad_get_element_private             (GstPad *pad);
 832
 833 GstPadTemplate*         gst_pad_get_pad_template                (GstPad *pad);
 834
 835 GstEvent*               gst_pad_get_sticky_event                (GstPad *pad, GstEventType event_type,
 836                                                                  guint idx);
 837 void                    gst_pad_sticky_events_foreach           (GstPad *pad, GstPadStickyEventsForeachFunction foreach_func, gpointer user_data);
 838
 839 /* data passing setup functions */
 840 void                    gst_pad_set_activate_function_full      (GstPad *pad,
 841                                                                  GstPadActivateFunction activate,
 842                                                                  GDestroyNotify notify);
 843 void                    gst_pad_set_activatemode_function_full  (GstPad *pad,
 844                                                                  GstPadActivateModeFunction activatemode,
 845                                                                  GDestroyNotify notify);
 846 /* data passing functions */
 847 void                    gst_pad_set_chain_function_full         (GstPad *pad,
 848                                                                  GstPadChainFunction chain,
 849                                                                  GDestroyNotify notify);
 850 void                    gst_pad_set_chain_list_function_full    (GstPad *pad,
 851                                                                  GstPadChainListFunction chainlist,
 852                                                                  GDestroyNotify notify);
 853 void                    gst_pad_set_getrange_function_full      (GstPad *pad,
 854                                                                  GstPadGetRangeFunction get,
 855                                                                  GDestroyNotify notify);
 856 void                    gst_pad_set_event_function_full         (GstPad *pad,
 857                                                                  GstPadEventFunction event,
 858                                                                  GDestroyNotify notify);
 859
 860 #define gst_pad_set_activate_function(p,f)      gst_pad_set_activate_function_full((p),(f),NULL)
 861 #define gst_pad_set_activatemode_function(p,f)  gst_pad_set_activatemode_function_full((p),(f),NULL)
 862 #define gst_pad_set_chain_function(p,f)         gst_pad_set_chain_function_full((p),(f),NULL)
 863 #define gst_pad_set_chain_list_function(p,f)    gst_pad_set_chain_list_function_full((p),(f),NULL)
 864 #define gst_pad_set_getrange_function(p,f)      gst_pad_set_getrange_function_full((p),(f),NULL)
 865 #define gst_pad_set_event_function(p,f)         gst_pad_set_event_function_full((p),(f),NULL)
 866
 867 /* pad links */
 868 void                    gst_pad_set_link_function_full          (GstPad *pad,
 869                                                                  GstPadLinkFunction link,
 870                                                                  GDestroyNotify notify);
 871 void                    gst_pad_set_unlink_function_full        (GstPad *pad,
 872                                                                  GstPadUnlinkFunction unlink,
 873                                                                  GDestroyNotify notify);
 874
 875 #define gst_pad_set_link_function(p,f)          gst_pad_set_link_function_full((p),(f),NULL)
 876 #define gst_pad_set_unlink_function(p,f)        gst_pad_set_unlink_function_full((p),(f),NULL)
 877
 878 gboolean                gst_pad_can_link                        (GstPad *srcpad, GstPad *sinkpad);
 879 GstPadLinkReturn        gst_pad_link                            (GstPad *srcpad, GstPad *sinkpad);
 880 GstPadLinkReturn        gst_pad_link_full                       (GstPad *srcpad, GstPad *sinkpad, GstPadLinkCheck flags);
 881 gboolean                gst_pad_unlink                          (GstPad *srcpad, GstPad *sinkpad);
 882 gboolean                gst_pad_is_linked                       (GstPad *pad);
 883
 884 GstPad*                 gst_pad_get_peer                        (GstPad *pad);
 885
 886 GstCaps*                gst_pad_get_pad_template_caps           (GstPad *pad);
 887
 888 /* capsnego function for linked/unlinked pads */
 889 GstCaps *               gst_pad_get_current_caps                (GstPad * pad);
 890 gboolean                gst_pad_has_current_caps                (GstPad * pad);
 891 gboolean                gst_pad_set_caps                        (GstPad * pad, GstCaps *caps);
 892
 893 /* capsnego for linked pads */
 894 GstCaps *               gst_pad_get_allowed_caps                (GstPad * pad);
 895
 896 /* pad offsets */
 897 gint64                  gst_pad_get_offset                      (GstPad *pad);
 898 void                    gst_pad_set_offset                      (GstPad *pad, gint64 offset);
 899
 900 /* data passing functions to peer */
 901 GstFlowReturn           gst_pad_push                            (GstPad *pad, GstBuffer *buffer);
 902 GstFlowReturn           gst_pad_push_list                       (GstPad *pad, GstBufferList *list);
 903 GstFlowReturn           gst_pad_pull_range                      (GstPad *pad, guint64 offset, guint size,
 904                                                                  GstBuffer **buffer);
 905 gboolean                gst_pad_push_event                      (GstPad *pad, GstEvent *event);
 906 gboolean                gst_pad_event_default                   (GstPad *pad, GstObject *parent,
 907                                                                  GstEvent *event);
 908
 909 /* data passing functions on pad */
 910 GstFlowReturn           gst_pad_chain                           (GstPad *pad, GstBuffer *buffer);
 911 GstFlowReturn           gst_pad_chain_list                      (GstPad *pad, GstBufferList *list);
 912 GstFlowReturn           gst_pad_get_range                       (GstPad *pad, guint64 offset, guint size,
 913                                                                  GstBuffer **buffer);
 914 gboolean                gst_pad_send_event                      (GstPad *pad, GstEvent *event);
 915
 916 /* pad tasks */
 917 gboolean                gst_pad_start_task                      (GstPad *pad, GstTaskFunction func,
 918                                                                  gpointer data);
 919 gboolean                gst_pad_pause_task                      (GstPad *pad);
 920 gboolean                gst_pad_stop_task                       (GstPad *pad);
 921
 922 /* internal links */
 923 void                    gst_pad_set_iterate_internal_links_function_full (GstPad * pad,
 924                                                                  GstPadIterIntLinkFunction iterintlink,
 925                                                                  GDestroyNotify notify);
 926 GstIterator *           gst_pad_iterate_internal_links          (GstPad * pad);
 927 GstIterator *           gst_pad_iterate_internal_links_default  (GstPad * pad, GstObject *parent);
 928
 929 #define gst_pad_set_iterate_internal_links_function(p,f) gst_pad_set_iterate_internal_links_function_full((p),(f),NULL)
 930
 931 /* generic query function */
 932 gboolean                gst_pad_query                           (GstPad *pad, GstQuery *query);
 933 gboolean                gst_pad_peer_query                      (GstPad *pad, GstQuery *query);
 934 void                    gst_pad_set_query_function_full         (GstPad *pad, GstPadQueryFunction query,
 935                                                                  GDestroyNotify notify);
 936 gboolean                gst_pad_query_default                   (GstPad *pad, GstObject *parent,
 937                                                                  GstQuery *query);
 938
 939 #define gst_pad_set_query_function(p,f)   gst_pad_set_query_function_full((p),(f),NULL)
 940
 941 /* misc helper functions */
 942 gboolean                gst_pad_forward                         (GstPad *pad, GstPadForwardFunction forward,
 943                                                                  gpointer user_data);
 944
 945 G_END_DECLS
 946
 947 #endif /* __GST_PAD_H__ */