gst/gstelement.h

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *               2000,2004 Wim Taymans <wim@fluendo.com>
   4  *
   5  * gstelement.h: Header for GstElement
   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_ELEMENT_H__
  25 #define __GST_ELEMENT_H__
  26
  27 /* gstelement.h and gstelementfactory.h include eachother */
  28 typedef struct _GstElement GstElement;
  29 typedef struct _GstElementClass GstElementClass;
  30
  31 /* gstmessage.h needs State */
  32 /**
  33  * GstState:
  34  * @GST_STATE_VOID_PENDING     : no pending state.
  35  * @GST_STATE_NULL             : the NULL state or initial state of an element
  36  * @GST_STATE_READY            : the element is ready to go to PAUSED
  37  * @GST_STATE_PAUSED           : the element is PAUSED
  38  * @GST_STATE_PLAYING          : the element is PLAYING
  39  *
  40  * The posible states an element can be in.
  41  */
  42 typedef enum {
  43   GST_STATE_VOID_PENDING        = 0,
  44   GST_STATE_NULL                = 1,
  45   GST_STATE_READY               = 2,
  46   GST_STATE_PAUSED              = 3,
  47   GST_STATE_PLAYING             = 4
  48 } GstState;
  49
  50
  51 #include <gst/gstconfig.h>
  52 #include <gst/gstobject.h>
  53 #include <gst/gstpad.h>
  54 #include <gst/gstbus.h>
  55 #include <gst/gstclock.h>
  56 #include <gst/gstelementfactory.h>
  57 #include <gst/gstplugin.h>
  58 #include <gst/gstpluginfeature.h>
  59 #include <gst/gstindex.h>
  60 #include <gst/gstindexfactory.h>
  61 #include <gst/gstiterator.h>
  62 #include <gst/gstmessage.h>
  63 #include <gst/gsttaglist.h>
  64
  65 G_BEGIN_DECLS
  66
  67 #define GST_TYPE_ELEMENT                (gst_element_get_type ())
  68 #define GST_IS_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_ELEMENT))
  69 #define GST_IS_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_ELEMENT))
  70 #define GST_ELEMENT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_ELEMENT, GstElementClass))
  71 #define GST_ELEMENT(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_ELEMENT, GstElement))
  72 #define GST_ELEMENT_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_ELEMENT, GstElementClass))
  73 #define GST_ELEMENT_CAST(obj)           ((GstElement*)(obj))
  74
  75 /**
  76  * GstStateChangeReturn:
  77  * @GST_STATE_CHANGE_FAILURE   : the state change failed
  78  * @GST_STATE_CHANGE_SUCCESS   : the state change succeeded
  79  * @GST_STATE_CHANGE_ASYNC     : the state change will happen asynchronously
  80  * @GST_STATE_CHANGE_NO_PREROLL: the state change cannot be prerolled
  81  *
  82  * the possible return values from a state change function.
  83  */
  84 typedef enum {
  85   GST_STATE_CHANGE_FAILURE             = 0,
  86   GST_STATE_CHANGE_SUCCESS             = 1,
  87   GST_STATE_CHANGE_ASYNC               = 2,
  88   GST_STATE_CHANGE_NO_PREROLL          = 3
  89 } GstStateChangeReturn;
  90
  91 /* NOTE: this probably should be done with an #ifdef to decide
  92  * whether to safe-cast or to just do the non-checking cast.
  93  */
  94
  95 /**
  96  * GST_STATE:
  97  * @elem: a #GstElement to return state for.
  98  *
  99  * This macro returns the current #GstState of the element.
 100  */
 101 #define GST_STATE(elem)                 (GST_ELEMENT_CAST(elem)->current_state)
 102
 103 /**
 104  * GST_STATE_NEXT:
 105  * @elem: a #GstElement to return the next state for.
 106  *
 107  * This macro returns the next #GstState of the element.
 108  */
 109 #define GST_STATE_NEXT(elem)            (GST_ELEMENT_CAST(elem)->next_state)
 110
 111 /**
 112  * GST_STATE_PENDING:
 113  * @elem: a #GstElement to return the pending state for.
 114  *
 115  * This macro returns the currently pending #GstState of the element.
 116  */
 117 #define GST_STATE_PENDING(elem)         (GST_ELEMENT_CAST(elem)->pending_state)
 118
 119 /**
 120  * GST_STATE_RETURN:
 121  * @elem: a #GstElement to return the last state result for.
 122  *
 123  * This macro returns the last #GstStateChangeReturn value.
 124  */
 125 #define GST_STATE_RETURN(elem)          (GST_ELEMENT_CAST(elem)->last_return)
 126
 127 #define __GST_SIGN(val)                 ((val) < 0 ? -1 : ((val) > 0 ? 1 : 0))
 128 /**
 129  * GST_STATE_GET_NEXT:
 130  * @cur: A starting #GstState
 131  * @pending: A target #GstState
 132  *
 133  * Given a current state @cur and a target state @pending, calculate the next (intermediate)
 134  * #GstState.
 135  */
 136 #define GST_STATE_GET_NEXT(cur,pending)         ((cur) + __GST_SIGN ((gint)(pending) - (gint)(cur)))
 137 /**
 138  * GST_STATE_TRANSITION:
 139  * @cur: A current state
 140  * @next: A next state
 141  *
 142  * Given a current state @cur and a next state @next, calculate the associated
 143  * #GstStateChange transition.
 144  */
 145 #define GST_STATE_TRANSITION(cur,next)          (((cur)<<3)|(next))
 146 /**
 147  * GST_STATE_TRANSITION_CURRENT:
 148  * @trans: A #GstStateChange
 149  *
 150  * Given a state transition @trans, extract the current #GstState.
 151  */
 152 #define GST_STATE_TRANSITION_CURRENT(trans)     ((trans)>>3)
 153 /**
 154  * GST_STATE_TRANSITION_NEXT:
 155  * @trans: A #GstStateChange
 156  *
 157  * Given a state transition @trans, extract the next #GstState.
 158  */
 159 #define GST_STATE_TRANSITION_NEXT(trans)        ((trans)&0x7)
 160
 161 /**
 162  * GstStateChange:
 163  * @GST_STATE_CHANGE_NULL_TO_READY    : state change from NULL to READY
 164  * @GST_STATE_CHANGE_READY_TO_PAUSED  : state change from READY to PAUSED
 165  * @GST_STATE_CHANGE_PAUSED_TO_PLAYING: state change from PAUSED to PLAYING
 166  * @GST_STATE_CHANGE_PLAYING_TO_PAUSED: state change from PLAYING to PAUSED
 167  * @GST_STATE_CHANGE_PAUSED_TO_READY  : state change from PAUSED to READY
 168  * @GST_STATE_CHANGE_READY_TO_NULL    : state change from READY to NULL
 169  *
 170  * The different (interesting) state changes that are passed to the
 171  * state change functions of elements.
 172  */
 173 typedef enum /*< flags=0 >*/
 174 {
 175   GST_STATE_CHANGE_NULL_TO_READY        = (GST_STATE_NULL<<3) | GST_STATE_READY,
 176   GST_STATE_CHANGE_READY_TO_PAUSED      = (GST_STATE_READY<<3) | GST_STATE_PAUSED,
 177   GST_STATE_CHANGE_PAUSED_TO_PLAYING    = (GST_STATE_PAUSED<<3) | GST_STATE_PLAYING,
 178   GST_STATE_CHANGE_PLAYING_TO_PAUSED    = (GST_STATE_PLAYING<<3) | GST_STATE_PAUSED,
 179   GST_STATE_CHANGE_PAUSED_TO_READY      = (GST_STATE_PAUSED<<3) | GST_STATE_READY,
 180   GST_STATE_CHANGE_READY_TO_NULL        = (GST_STATE_READY<<3) | GST_STATE_NULL
 181 } GstStateChange;
 182
 183 /**
 184  * GstElementFlags:
 185  * @GST_ELEMENT_LOCKED_STATE: ignore state changes from parent
 186  * @GST_ELEMENT_IS_SINK: the element is a sink
 187  * @GST_ELEMENT_UNPARENTING: Child is being removed from the parent bin.
 188  *  gst_bin_remove() on a child already being removed immediately returns FALSE
 189  * @GST_ELEMENT_FLAG_LAST: offset to define more flags
 190  *
 191  * The standard flags that an element may have.
 192  */
 193 typedef enum
 194 {
 195   GST_ELEMENT_LOCKED_STATE      = (GST_OBJECT_FLAG_LAST << 0),
 196   GST_ELEMENT_IS_SINK           = (GST_OBJECT_FLAG_LAST << 1),
 197   GST_ELEMENT_UNPARENTING       = (GST_OBJECT_FLAG_LAST << 2),
 198   /* padding */
 199   GST_ELEMENT_FLAG_LAST         = (GST_OBJECT_FLAG_LAST << 16)
 200 } GstElementFlags;
 201
 202 /**
 203  * GST_ELEMENT_IS_LOCKED_STATE:
 204  * @elem: A #GstElement to query
 205  *
 206  * Check if the element is in the locked state and therefore will ignore state
 207  * changes from its parent object.
 208  */
 209 #define GST_ELEMENT_IS_LOCKED_STATE(elem)        (GST_OBJECT_FLAG_IS_SET(elem,GST_ELEMENT_LOCKED_STATE))
 210
 211 /**
 212  * GST_ELEMENT_NAME:
 213  * @elem: A #GstElement to query
 214  *
 215  * Gets the name of this element. Use only in core as this is not
 216  * ABI-compatible. Others use gst_element_get_name()
 217  */
 218 #define GST_ELEMENT_NAME(elem)                  (GST_OBJECT_NAME(elem))
 219
 220 /**
 221  * GST_ELEMENT_PARENT:
 222  * @elem: A #GstElement to query
 223  *
 224  * Get the parent object of this element.
 225  */
 226 #define GST_ELEMENT_PARENT(elem)                (GST_ELEMENT_CAST(GST_OBJECT_PARENT(elem)))
 227
 228 /**
 229  * GST_ELEMENT_BUS:
 230  * @elem: A #GstElement to query
 231  *
 232  * Get the message bus of this element.
 233  */
 234 #define GST_ELEMENT_BUS(elem)                   (GST_ELEMENT_CAST(elem)->bus)
 235
 236 /**
 237  * GST_ELEMENT_CLOCK:
 238  * @elem: A #GstElement to query
 239  *
 240  * Get the clock of this element
 241  */
 242 #define GST_ELEMENT_CLOCK(elem)                 (GST_ELEMENT_CAST(elem)->clock)
 243
 244 /**
 245  * GST_ELEMENT_PADS:
 246  * @elem: A #GstElement to query
 247  *
 248  * Get the pads of this elements.
 249  */
 250 #define GST_ELEMENT_PADS(elem)                  (GST_ELEMENT_CAST(elem)->pads)
 251
 252 /**
 253  * GST_ELEMENT_ERROR:
 254  * @el:     the element that throws the error
 255  * @domain: like CORE, LIBRARY, RESOURCE or STREAM (see #GstGError)
 256  * @code:   error code defined for that domain (see #GstGError)
 257  * @text:   the message to display (format string and args enclosed in
 258             parentheses)
 259  * @debug:  debugging information for the message (format string and args
 260             enclosed in parentheses)
 261  *
 262  * Utility function that elements can use in case they encountered a fatal
 263  * data processing error. The pipeline will throw an error signal and the
 264  * application will be requested to stop further media processing.
 265  */
 266 #define GST_ELEMENT_ERROR(el, domain, code, text, debug)                \
 267 G_STMT_START {                                                          \
 268   gchar *__txt = _gst_element_error_printf text;                        \
 269   gchar *__dbg = _gst_element_error_printf debug;                       \
 270   if (__txt)                                                            \
 271     GST_WARNING_OBJECT (el, "error: %s", __txt);                        \
 272   if (__dbg)                                                            \
 273     GST_WARNING_OBJECT (el, "error: %s", __dbg);                        \
 274   gst_element_message_full (GST_ELEMENT(el), GST_MESSAGE_ERROR,         \
 275     GST_ ## domain ## _ERROR, GST_ ## domain ## _ERROR_ ## code,        \
 276     __txt, __dbg, __FILE__, GST_FUNCTION, __LINE__);                    \
 277 } G_STMT_END
 278
 279 /**
 280  * GST_ELEMENT_WARNING:
 281  * @el:     the element that throws the error
 282  * @domain: like CORE, LIBRARY, RESOURCE or STREAM (see #GstGError)
 283  * @code:   error code defined for that domain (see #GstGError)
 284  * @text:   the message to display (format string and args enclosed in
 285             parentheses)
 286  * @debug:  debugging information for the message (format string and args
 287             enclosed in parentheses)
 288  *
 289  * Utility function that elements can use in case they encountered a non-fatal
 290  * data processing problem. The pipeline will throw a warning signal and the
 291  * application will be informed.
 292  */
 293 #define GST_ELEMENT_WARNING(el, domain, code, text, debug)              \
 294 G_STMT_START {                                                          \
 295   gchar *__txt = _gst_element_error_printf text;                        \
 296   gchar *__dbg = _gst_element_error_printf debug;                       \
 297   if (__txt)                                                            \
 298     GST_WARNING_OBJECT (el, "warning: %s", __txt);                      \
 299   if (__dbg)                                                            \
 300     GST_WARNING_OBJECT (el, "warning: %s", __dbg);                      \
 301   gst_element_message_full (GST_ELEMENT(el), GST_MESSAGE_WARNING,       \
 302     GST_ ## domain ## _ERROR, GST_ ## domain ## _ERROR_ ## code,        \
 303   __txt, __dbg, __FILE__, GST_FUNCTION, __LINE__);                      \
 304 } G_STMT_END
 305
 306 /* the state change mutexes and conds */
 307 /**
 308  * GST_STATE_GET_LOCK:
 309  * @elem:   a #GstElement
 310  *
 311  * Get a reference to the state lock of @elem.
 312  * This lock is used by the core.  It is taken while getting or setting
 313  * the state, during state changes, and while finalizing.
 314  */
 315 #define GST_STATE_GET_LOCK(elem)               (GST_ELEMENT_CAST(elem)->state_lock)
 316 /**
 317  * GST_STATE_GET_COND:
 318  * @elem: a #GstElement
 319  *
 320  * Get the conditional used to signal the completion of a state change.
 321  */
 322 #define GST_STATE_GET_COND(elem)               (GST_ELEMENT_CAST(elem)->state_cond)
 323
 324 #define GST_STATE_LOCK(elem)                   g_static_rec_mutex_lock(GST_STATE_GET_LOCK(elem))
 325 #define GST_STATE_TRYLOCK(elem)                g_static_rec_mutex_trylock(GST_STATE_GET_LOCK(elem))
 326 #define GST_STATE_UNLOCK(elem)                 g_static_rec_mutex_unlock(GST_STATE_GET_LOCK(elem))
 327 #define GST_STATE_UNLOCK_FULL(elem)            g_static_rec_mutex_unlock_full(GST_STATE_GET_LOCK(elem))
 328 #define GST_STATE_LOCK_FULL(elem,t)            g_static_rec_mutex_lock_full(GST_STATE_GET_LOCK(elem), t)
 329 #define GST_STATE_WAIT(elem)                   g_cond_wait (GST_STATE_GET_COND (elem), \
 330                                                         GST_OBJECT_GET_LOCK (elem))
 331 #define GST_STATE_TIMED_WAIT(elem, timeval)    g_cond_timed_wait (GST_STATE_GET_COND (elem), \
 332                                                         GST_OBJECT_GET_LOCK (elem), timeval)
 333 #define GST_STATE_SIGNAL(elem)                 g_cond_signal (GST_STATE_GET_COND (elem));
 334 #define GST_STATE_BROADCAST(elem)              g_cond_broadcast (GST_STATE_GET_COND (elem));
 335
 336 /**
 337  * GstElement:
 338  * @state_lock: Used to serialize execution of gst_element_set_state()
 339  * @state_cond: Used to signal completion of a state change
 340  * @state_cookie: Used to detect concurrent execution of
 341  * gst_element_set_state() and gst_element_get_state()
 342  * @current_state: the current state of an element
 343  * @next_state: the next state of an element, can be #GST_STATE_VOID_PENDING if
 344  * the element is in the correct state.
 345  * @pending_state: the final state the element should go to, can be
 346  * #GST_STATE_VOID_PENDING if the element is in the correct state
 347  * @last_return: the last return value of an element state change
 348  * @bus: the bus of the element. This bus is provided to the element by the
 349  * parent element or the application. A #GstPipeline has a bus of its own.
 350  * @clock: the clock of the element. This clock is usually provided by to the
 351  * element by the toplevel #GstPipeline.
 352  * @base_time: the time of the clock right before the element is set to
 353  * PLAYING. Subtracting @base_time from the current clock time in the PLAYING
 354  * state will yield the stream time.
 355  * @numpads: number of pads of the element, includes both source and sink pads.
 356  * @pads: list of pads
 357  * @numsrcpads: number of source pads of the element.
 358  * @srcpads: list of source pads
 359  * @numsinkpads: number of sink pads of the element.
 360  * @sinkpads: list of sink pads
 361  * @pads_cookie: updated whenever the a pad is added or removed
 362  *
 363  * GStreamer element abstract base class.
 364  */
 365 struct _GstElement
 366 {
 367   GstObject             object;
 368
 369   /*< public >*/ /* with LOCK */
 370   GStaticRecMutex      *state_lock;
 371
 372   /* element state */
 373   GCond                *state_cond;
 374   guint32               state_cookie;
 375   GstState              current_state;
 376   GstState              next_state;
 377   GstState              pending_state;
 378   GstStateChangeReturn  last_return;
 379
 380   GstBus               *bus;
 381
 382   /* allocated clock */
 383   GstClock             *clock;
 384   GstClockTimeDiff      base_time; /* NULL/READY: 0 - PAUSED: current time - PLAYING: difference to clock */
 385
 386   /* element pads, these lists can only be iterated while holding
 387    * the LOCK or checking the cookie after each LOCK. */
 388   guint16               numpads;
 389   GList                *pads;
 390   guint16               numsrcpads;
 391   GList                *srcpads;
 392   guint16               numsinkpads;
 393   GList                *sinkpads;
 394   guint32               pads_cookie;
 395
 396   /*< private >*/
 397   gpointer _gst_reserved[GST_PADDING];
 398 };
 399
 400 /**
 401  * GstElementClass:
 402  * @parent_class: the parent class structure
 403  * @details: #GstElementDetails for elements of this class
 404  * @elementfactory: the #GstElementFactory that creates these elements
 405  * @padtemplates: a #GList of #GstPadTemplate
 406  * @numpadtemplates: the number of padtemplates
 407  * @pad_templ_cookie: changed whenever the padtemplates change
 408  * @request_new_pad: called when a new pad is requested
 409  * @release_pad: called when a request pad is to be released
 410  * @get_state: get the state of the element
 411  * @set_state: set a new state on the element
 412  * @change_state: called by @set_state to perform an incremental state change
 413  * @set_bus: set a #GstBus on the element
 414  * @provide_clock: gets the #GstClock provided by the element
 415  * @set_clock: set the #GstClock on the element
 416  * @get_index: set a #GstIndex on the element
 417  * @set_index: get the #GstIndex of an element
 418  * @send_event: send a #GstEvent to the element
 419  * @get_query_types: get the supported #GstQueryType of this element
 420  * @query: perform a #GstQuery on the element
 421  *
 422  * GStreamer element class. Override the vmethods to implement the element
 423  * functionality.
 424  */
 425 struct _GstElementClass
 426 {
 427   GstObjectClass         parent_class;
 428
 429   /*< public >*/
 430   /* the element details */
 431   GstElementDetails      details;
 432
 433   /* factory that the element was created from */
 434   GstElementFactory     *elementfactory;
 435
 436   /* templates for our pads */
 437   GList                 *padtemplates;
 438   gint                   numpadtemplates;
 439   guint32                pad_templ_cookie;
 440
 441   /*< private >*/
 442   /* signal callbacks */
 443   void (*pad_added)     (GstElement *element, GstPad *pad);
 444   void (*pad_removed)   (GstElement *element, GstPad *pad);
 445   void (*no_more_pads)  (GstElement *element);
 446
 447   /*< public >*/
 448   /* virtual methods for subclasses */
 449
 450   /* request/release pads */
 451   GstPad*               (*request_new_pad)      (GstElement *element, GstPadTemplate *templ, const gchar* name);
 452   void                  (*release_pad)          (GstElement *element, GstPad *pad);
 453
 454   /* state changes */
 455   GstStateChangeReturn (*get_state)             (GstElement * element, GstState * state,
 456                                                  GstState * pending, GstClockTime timeout);
 457   GstStateChangeReturn (*set_state)             (GstElement *element, GstState state);
 458   GstStateChangeReturn (*change_state)          (GstElement *element, GstStateChange transition);
 459
 460   /* bus */
 461   void                  (*set_bus)              (GstElement * element, GstBus * bus);
 462
 463   /* set/get clocks */
 464   GstClock*             (*provide_clock)        (GstElement *element);
 465   gboolean              (*set_clock)            (GstElement *element, GstClock *clock);
 466
 467   /* index */
 468   GstIndex*             (*get_index)            (GstElement *element);
 469   void                  (*set_index)            (GstElement *element, GstIndex *index);
 470
 471   /* query functions */
 472   gboolean              (*send_event)           (GstElement *element, GstEvent *event);
 473
 474   const GstQueryType*   (*get_query_types)      (GstElement *element);
 475   gboolean              (*query)                (GstElement *element, GstQuery *query);
 476
 477   /*< private >*/
 478   gpointer _gst_reserved[GST_PADDING];
 479 };
 480
 481 /* element class pad templates */
 482 void                    gst_element_class_add_pad_template      (GstElementClass *klass, GstPadTemplate *templ);
 483 GstPadTemplate*         gst_element_class_get_pad_template      (GstElementClass *element_class, const gchar *name);
 484 GList*                  gst_element_class_get_pad_template_list (GstElementClass *element_class);
 485 void                    gst_element_class_set_details           (GstElementClass *klass,
 486                                                                  const GstElementDetails *details);
 487
 488 /* element instance */
 489 GType                   gst_element_get_type            (void);
 490
 491 /* basic name and parentage stuff from GstObject */
 492
 493 /**
 494  * gst_element_get_name:
 495  * @elem: a #GstElement to set the name of.
 496  *
 497  * Gets the name of the element.
 498  */
 499 #define                 gst_element_get_name(elem)      gst_object_get_name(GST_OBJECT_CAST(elem))
 500
 501 /**
 502  * gst_element_set_name:
 503  * @elem: a #GstElement to set the name of.
 504  * @name: the new name
 505  *
 506  * Sets the name of the element, getting rid of the old name if there was one.
 507  */
 508 #define                 gst_element_set_name(elem,name) gst_object_set_name(GST_OBJECT_CAST(elem),name)
 509
 510 /**
 511  * gst_element_get_parent:
 512  * @elem: a #GstElement to get the parent of.
 513  *
 514  * Gets the parent of an element.
 515  */
 516 #define                 gst_element_get_parent(elem)    gst_object_get_parent(GST_OBJECT_CAST(elem))
 517
 518 /**
 519  * gst_element_set_parent:
 520  * @elem: a #GstElement to set the parent of.
 521  * @parent: the new parent #GstObject of the element.
 522  *
 523  * Sets the parent of an element.
 524  */
 525 #define                 gst_element_set_parent(elem,parent)     gst_object_set_parent(GST_OBJECT_CAST(elem),parent)
 526
 527 /* clocking */
 528 gboolean                gst_element_requires_clock      (GstElement *element);
 529 gboolean                gst_element_provides_clock      (GstElement *element);
 530 GstClock*               gst_element_provide_clock       (GstElement *element);
 531 GstClock*               gst_element_get_clock           (GstElement *element);
 532 gboolean                gst_element_set_clock           (GstElement *element, GstClock *clock);
 533 void                    gst_element_set_base_time       (GstElement *element, GstClockTime time);
 534 GstClockTime            gst_element_get_base_time       (GstElement *element);
 535
 536 /* indexes */
 537 gboolean                gst_element_is_indexable        (GstElement *element);
 538 void                    gst_element_set_index           (GstElement *element, GstIndex *index);
 539 GstIndex*               gst_element_get_index           (GstElement *element);
 540
 541 /* bus */
 542 void                    gst_element_set_bus             (GstElement * element, GstBus * bus);
 543 GstBus *                gst_element_get_bus             (GstElement * element);
 544
 545 /* pad management */
 546 gboolean                gst_element_add_pad             (GstElement *element, GstPad *pad);
 547 gboolean                gst_element_remove_pad          (GstElement *element, GstPad *pad);
 548 void                    gst_element_no_more_pads        (GstElement *element);
 549
 550 GstPad*                 gst_element_get_pad             (GstElement *element, const gchar *name);
 551 GstPad*                 gst_element_get_static_pad      (GstElement *element, const gchar *name);
 552 GstPad*                 gst_element_get_request_pad     (GstElement *element, const gchar *name);
 553 void                    gst_element_release_request_pad (GstElement *element, GstPad *pad);
 554
 555 GstIterator *           gst_element_iterate_pads        (GstElement * element);
 556 GstIterator *           gst_element_iterate_src_pads    (GstElement * element);
 557 GstIterator *           gst_element_iterate_sink_pads   (GstElement * element);
 558
 559 /* event/query/format stuff */
 560 gboolean                gst_element_send_event          (GstElement *element, GstEvent *event);
 561 gboolean                gst_element_seek                (GstElement *element, gdouble rate,
 562                                                          GstFormat format, GstSeekFlags flags,
 563                                                          GstSeekType cur_type, gint64 cur,
 564                                                          GstSeekType stop_type, gint64 stop);
 565 G_CONST_RETURN GstQueryType*
 566                         gst_element_get_query_types     (GstElement *element);
 567 gboolean                gst_element_query               (GstElement *element, GstQuery *query);
 568
 569 /* messages */
 570 gboolean                gst_element_post_message        (GstElement * element, GstMessage * message);
 571
 572 /* error handling */
 573 gchar *                 _gst_element_error_printf       (const gchar *format, ...);
 574 void                    gst_element_message_full        (GstElement * element, GstMessageType type,
 575                                                          GQuark domain, gint code, gchar * text,
 576                                                          gchar * debug, const gchar * file,
 577                                                          const gchar * function, gint line);
 578
 579 /* state management */
 580 gboolean                gst_element_is_locked_state     (GstElement *element);
 581 gboolean                gst_element_set_locked_state    (GstElement *element, gboolean locked_state);
 582 gboolean                gst_element_sync_state_with_parent (GstElement *element);
 583
 584 GstStateChangeReturn    gst_element_get_state           (GstElement * element,
 585                                                          GstState * state,
 586                                                          GstState * pending,
 587                                                          GstClockTime timeout);
 588 GstStateChangeReturn    gst_element_set_state           (GstElement *element, GstState state);
 589
 590 void                    gst_element_abort_state         (GstElement * element);
 591 GstStateChangeReturn    gst_element_continue_state      (GstElement * element,
 592                                                          GstStateChangeReturn ret);
 593 void                    gst_element_lost_state          (GstElement * element);
 594
 595 /* factory management */
 596 GstElementFactory*      gst_element_get_factory         (GstElement *element);
 597
 598 G_END_DECLS
 599
 600 #endif /* __GST_ELEMENT_H__ */