gstreamer/docs/gst/gstreamer-decl.txt

<MACRO>
<NAME>COTHREAD_STACKSIZE</NAME>
#define COTHREAD_STACKSIZE 8192
</MACRO>
<MACRO>
<NAME>COTHREAD_MAXTHREADS</NAME>
#define COTHREAD_MAXTHREADS 16
</MACRO>
<MACRO>
<NAME>STACK_SIZE</NAME>
#define STACK_SIZE 0x200000
</MACRO>
<MACRO>
<NAME>CURRENT_STACK_FRAME</NAME>
#define CURRENT_STACK_FRAME  ({ char __csf; &__csf; })
</MACRO>
<STRUCT>
<NAME>cothread_state</NAME>
</STRUCT>
<STRUCT>
<NAME>cothread_context</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>cothread_func</NAME>
<RETURNS>int </RETURNS>
int argc,char **argv
</USER_FUNCTION>
<MACRO>
<NAME>COTHREAD_STARTED</NAME>
#define COTHREAD_STARTED	0x01
</MACRO>
<STRUCT>
<NAME>cothread_state</NAME>
struct cothread_state {
  cothread_context *ctx;
  int threadnum;

  cothread_func func;
  int argc;
  char **argv;

  int flags;
  int *sp;
  int *top_sp;
  int *pc;
  jmp_buf jmp;
};
</STRUCT>
<STRUCT>
<NAME>cothread_context</NAME>
struct cothread_context {
  cothread_state *threads[COTHREAD_MAXTHREADS];
  int nthreads;
  int current;
  GHashTable *data;
};
</STRUCT>
<FUNCTION>
<NAME>cothread_init</NAME>
<RETURNS>cothread_context *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>cothread_create</NAME>
<RETURNS>cothread_state *</RETURNS>
cothread_context *ctx
</FUNCTION>
<FUNCTION>
<NAME>cothread_setfunc</NAME>
<RETURNS>void  </RETURNS>
cothread_state *thread, cothread_func func,int argc, char **argv
</FUNCTION>
<FUNCTION>
<NAME>cothread_getcurrent</NAME>
<RETURNS>int 	</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>cothread_switch</NAME>
<RETURNS>void  </RETURNS>
cothread_state *thread
</FUNCTION>
<FUNCTION>
<NAME>cothread_set_data</NAME>
<RETURNS>void  </RETURNS>
cothread_state *thread, gchar *key, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>cothread_get_data</NAME>
<RETURNS>gpointer  </RETURNS>
cothread_state *thread, gchar *key
</FUNCTION>
<FUNCTION>
<NAME>cothread_main</NAME>
<RETURNS>cothread_state *</RETURNS>
cothread_context *ctx
</FUNCTION>
<FUNCTION>
<NAME>gst_init</NAME>
<RETURNS>void  </RETURNS>
int *argc,char **argv[]
</FUNCTION>
<FUNCTION>
<NAME>gst_main</NAME>
<RETURNS>void  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_main_quit</NAME>
<RETURNS>void  </RETURNS>
void
</FUNCTION>
<VARIABLE>
<NAME>gst_bin_details</NAME>
extern GstElementDetails gst_bin_details;
</VARIABLE>
<MACRO>
<NAME>GST_TYPE_BIN</NAME>
#define GST_TYPE_BIN \
  (gst_bin_get_type())
</MACRO>
<MACRO>
<NAME>GST_BIN</NAME>
#define GST_BIN(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_BIN,GstBin))
</MACRO>
<MACRO>
<NAME>GST_BIN_CLASS</NAME>
#define GST_BIN_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_BIN,GstBinClass))
</MACRO>
<MACRO>
<NAME>GST_IS_BIN</NAME>
#define GST_IS_BIN(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_BIN))
</MACRO>
<MACRO>
<NAME>GST_IS_BIN_CLASS</NAME>
#define GST_IS_BIN_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_BIN))
</MACRO>
<ENUM>
<NAME>GstBinFlags</NAME>
typedef enum {
  /* this bin is a manager of child elements, i.e. a pipeline or thread */
  GST_BIN_FLAG_MANAGER		= GST_ELEMENT_FLAG_LAST,

  /* we prefer to have cothreads when its an option, over chain-based */
  GST_BIN_FLAG_PREFER_COTHREADS,

  /* padding */
  GST_BIN_FLAG_LAST		= GST_ELEMENT_FLAG_LAST + 4,
} GstBinFlags;
</ENUM>
<STRUCT>
<NAME>GstBin</NAME>
</STRUCT>
<STRUCT>
<NAME>GstBinClass</NAME>
</STRUCT>
<STRUCT>
<NAME>_GstBinChain</NAME>
</STRUCT>
<STRUCT>
<NAME>GstBin</NAME>
struct GstBin {
  GstElement element;

  /* our children */
  gint numchildren;
  GList *children;

  /* iteration state */
  gboolean need_cothreads;
  GList *managed_elements;
  gint num_managed_elements;

  GList *chains;
  gint num_chains;
  GList *entries;
  gint num_entries;

  cothread_context *threadcontext;
  gboolean use_cothreads;
};
</STRUCT>
<STRUCT>
<NAME>_GstBinChain</NAME>
struct _GstBinChain {
  GList *elements;
  gint num_elements;

  GList *entries;

  gboolean need_cothreads;
};  
</STRUCT>
<FUNCTION>
<NAME>gst_bin_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_new</NAME>
<RETURNS>GstElement *</RETURNS>
gchar *name
</FUNCTION>
<MACRO>
<NAME>gst_bin_destroy</NAME>
#define 	gst_bin_destroy(bin) 		gst_object_destroy(GST_OBJECT(bin))
</MACRO>
<FUNCTION>
<NAME>gst_bin_add</NAME>
<RETURNS>void  </RETURNS>
GstBin *bin,GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_remove</NAME>
<RETURNS>void  </RETURNS>
GstBin *bin,GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_get_by_name</NAME>
<RETURNS>GstElement *</RETURNS>
GstBin *bin,gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_get_list</NAME>
<RETURNS>GList *</RETURNS>
GstBin *bin
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_create_plan</NAME>
<RETURNS>void  </RETURNS>
GstBin *bin
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_schedule</NAME>
<RETURNS>void  </RETURNS>
GstBin *bin
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_set_state_type</NAME>
<RETURNS>gboolean  </RETURNS>
GstBin *bin,GstElementState state,GtkType type
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_iterate</NAME>
<RETURNS>void  </RETURNS>
GstBin *bin
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_use_cothreads</NAME>
<RETURNS>void  </RETURNS>
GstBin *bin,gboolean enabled
</FUNCTION>
<MACRO>
<NAME>GST_BUFFER</NAME>
#define GST_BUFFER(buf) \
  ((GstBuffer *)(buf))
</MACRO>
<MACRO>
<NAME>GST_BUFFER_FLAGS</NAME>
#define GST_BUFFER_FLAGS(buf) \
  (GST_BUFFER(buf)->flags)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_FLAG_IS_SET</NAME>
#define GST_BUFFER_FLAG_IS_SET(buf,flag) \
  (GST_BUFFER_FLAGS(buf) & (flag))
</MACRO>
<MACRO>
<NAME>GST_BUFFER_FLAG_SET</NAME>
#define GST_BUFFER_FLAG_SET(buf,flag) \
  G_STMT_START{ (GST_BUFFER_FLAGS(buf) |= (flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_BUFFER_FLAG_UNSET</NAME>
#define GST_BUFFER_FLAG_UNSET(buf,flag) \
  G_STMT_START{ (GST_BUFFER_FLAGS(buf) &= ~(flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_BUFFER_TYPE</NAME>
#define GST_BUFFER_TYPE(buf)		(GST_BUFFER(buf)->type)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_DATA</NAME>
#define GST_BUFFER_DATA(buf)		(GST_BUFFER(buf)->data)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_SIZE</NAME>
#define GST_BUFFER_SIZE(buf)		(GST_BUFFER(buf)->size)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_OFFSET</NAME>
#define GST_BUFFER_OFFSET(buf)		(GST_BUFFER(buf)->offset)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_MAXSIZE</NAME>
#define GST_BUFFER_MAXSIZE(buf)		(GST_BUFFER(buf)->maxsize)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_TIMESTAMP</NAME>
#define GST_BUFFER_TIMESTAMP(buf)	(GST_BUFFER(buf)->timestamp)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_LOCK</NAME>
#define GST_BUFFER_LOCK(buf)	(g_mutex_lock(GST_BUFFER(buf)->lock))
</MACRO>
<MACRO>
<NAME>GST_BUFFER_TRYLOCK</NAME>
#define GST_BUFFER_TRYLOCK(buf)	(g_mutex_trylock(GST_BUFFER(buf)->lock))
</MACRO>
<MACRO>
<NAME>GST_BUFFER_UNLOCK</NAME>
#define GST_BUFFER_UNLOCK(buf)	(g_mutex_unlock(GST_BUFFER(buf)->lock))
</MACRO>
<ENUM>
<NAME>GstBufferFlags</NAME>
typedef enum {
  GST_BUFFER_READONLY,
  GST_BUFFER_ORIGINAL,
  GST_BUFFER_DONTFREE,
  GST_BUFFER_FLUSH,
  GST_BUFFER_EOS,
} GstBufferFlags;
</ENUM>
<STRUCT>
<NAME>GstBuffer</NAME>
</STRUCT>
<STRUCT>
<NAME>GstBuffer</NAME>
struct GstBuffer {
  /* locking */
  GMutex *lock;

  /* refcounting */
#ifdef HAVE_ATOMIC_H
  atomic_t refcount;
#define GST_BUFFER_REFCOUNT(buf)	(atomic_read(&(GST_BUFFER((buf))->refcount)))
#else
  int refcount;
#define GST_BUFFER_REFCOUNT(buf)	(GST_BUFFER(buf)->refcount)
#endif

  /* data type of this buffer */
  guint16 type;
  /* flags */
  guint16 flags;

  /* pointer to data, its size, and offset in original source if known */
  guchar *data;
  guint32 size;
  guint32 maxsize;
  guint32 offset;

  /* timestamp */
  guint64 timestamp;
  /* max age */
  guint64 maxage;

  /* pointer to metadata, is really lame right now */
  GSList *metas;

  /* subbuffer support, who's my parent? */
  GstBuffer *parent;

  /* this is a pointer to the buffer pool (if any) */
  GstBufferPool *pool;
};
</STRUCT>
<FUNCTION>
<NAME>gst_buffer_new</NAME>
<RETURNS>GstBuffer *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_new_from_pool</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstBufferPool *pool
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_create_sub</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstBuffer *parent, guint32 offset, guint32 size
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_append</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstBuffer *buffer, GstBuffer *append
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_ref</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_ref_by_count</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer, int count
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_unref</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_destroy</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_add_meta</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer, GstMeta *meta
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_remove_meta</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer, GstMeta *meta
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_get_first_meta</NAME>
<RETURNS>GstMeta *</RETURNS>
GstBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_get_metas</NAME>
<RETURNS>GSList *</RETURNS>
GstBuffer *buffer
</FUNCTION>
<TYPEDEF>
<NAME>GstClockTime</NAME>
typedef guint64 GstClockTime;
</TYPEDEF>
<TYPEDEF>
<NAME>GstClockTimeDiff</NAME>
typedef gint64 GstClockTimeDiff;
</TYPEDEF>
<MACRO>
<NAME>GST_CLOCK_DIFF</NAME>
#define GST_CLOCK_DIFF(s, e) (GstClockTimeDiff)((s)-(e))
</MACRO>
<STRUCT>
<NAME>GstClock</NAME>
</STRUCT>
<STRUCT>
<NAME>GstClock</NAME>
struct GstClock {
  gchar *name;
  GstClockTime start_time;
  GstClockTime current_time;
  GstClockTimeDiff adjust;
  gboolean locking;
  GList *sinkobjects;
  gint num, num_locked;
  GMutex *sinkmutex;
  GMutex *lock;
};
</STRUCT>
<FUNCTION>
<NAME>gst_clock_new</NAME>
<RETURNS>GstClock *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_clock_get_system</NAME>
<RETURNS>GstClock *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_clock_register</NAME>
<RETURNS>void  </RETURNS>
GstClock *clock, GstObject *obj
</FUNCTION>
<FUNCTION>
<NAME>gst_clock_set</NAME>
<RETURNS>void  </RETURNS>
GstClock *clock, GstClockTime time
</FUNCTION>
<FUNCTION>
<NAME>gst_clock_reset</NAME>
<RETURNS>void  </RETURNS>
GstClock *clock
</FUNCTION>
<FUNCTION>
<NAME>gst_clock_wait</NAME>
<RETURNS>void  </RETURNS>
GstClock *clock, GstClockTime time, GstObject *obj
</FUNCTION>
<FUNCTION>
<NAME>gst_clock_current_diff</NAME>
<RETURNS>GstClockTimeDiff  </RETURNS>
GstClock *clock, GstClockTime time
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_CONNECTION</NAME>
#define GST_TYPE_CONNECTION \
  (gst_connection_get_type())
</MACRO>
<MACRO>
<NAME>GST_CONNECTION</NAME>
#define GST_CONNECTION(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_CONNECTION,GstConnection))
</MACRO>
<MACRO>
<NAME>GST_CONNECTION_CLASS</NAME>
#define GST_CONNECTION_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_CONNECTION,GstConnectionClass))
</MACRO>
<MACRO>
<NAME>GST_IS_CONNECTION</NAME>
#define GST_IS_CONNECTION(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_CONNECTION))
</MACRO>
<MACRO>
<NAME>GST_IS_CONNECTION_CLASS</NAME>
#define GST_IS_CONNECTION_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_CONNECTION))
</MACRO>
<STRUCT>
<NAME>GstConnection</NAME>
</STRUCT>
<STRUCT>
<NAME>GstConnectionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstConnection</NAME>
struct GstConnection {
  GstElement element;
};
</STRUCT>
<FUNCTION>
<NAME>gst_connection_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_connection_new</NAME>
<RETURNS>GstElement *</RETURNS>
gchar *name
</FUNCTION>
<ENUM>
<NAME>GstElementState</NAME>
typedef enum {
  GST_STATE_NONE_PENDING	= -1,
  GST_STATE_NULL		= 0,
  GST_STATE_READY		= 1,
  GST_STATE_PLAYING		= 2,
  GST_STATE_PAUSED		= 3,
} GstElementState;
</ENUM>
<ENUM>
<NAME>GstElementStateReturn</NAME>
typedef enum {
  GST_STATE_FAILURE		= 0,
  GST_STATE_SUCCESS		= 1,
  GST_STATE_ASYNC		= 2,
} GstElementStateReturn;
</ENUM>
<MACRO>
<NAME>GST_STATE</NAME>
#define GST_STATE(obj)			(GST_ELEMENT(obj)->current_state)
</MACRO>
<MACRO>
<NAME>GST_STATE_PENDING</NAME>
#define GST_STATE_PENDING(obj)		(GST_ELEMENT(obj)->pending_state)
</MACRO>
<MACRO>
<NAME>GST_STATE_TRANSITION</NAME>
#define GST_STATE_TRANSITION(obj)	((GST_STATE(obj)<<4) | GST_STATE_PENDING(obj))
</MACRO>
<MACRO>
<NAME>GST_STATE_NULL_TO_READY</NAME>
#define GST_STATE_NULL_TO_READY 	((GST_STATE_NULL<<4) | GST_STATE_READY)
</MACRO>
<MACRO>
<NAME>GST_STATE_READY_TO_PLAYING</NAME>
#define GST_STATE_READY_TO_PLAYING 	((GST_STATE_READY<<4) | GST_STATE_PLAYING)
</MACRO>
<MACRO>
<NAME>GST_STATE_PLAYING_TO_PAUSED</NAME>
#define GST_STATE_PLAYING_TO_PAUSED	((GST_STATE_PLAYING<<4) | GST_STATE_PAUSED)
</MACRO>
<MACRO>
<NAME>GST_STATE_PAUSED_TO_PLAYING</NAME>
#define GST_STATE_PAUSED_TO_PLAYING	((GST_STATE_PAUSED<<4) | GST_STATE_PLAYING)
</MACRO>
<MACRO>
<NAME>GST_STATE_PLAYING_TO_READY</NAME>
#define GST_STATE_PLAYING_TO_READY 	((GST_STATE_PLAYING<<4) | GST_STATE_READY)
</MACRO>
<MACRO>
<NAME>GST_STATE_READY_TO_NULL</NAME>
#define GST_STATE_READY_TO_NULL		((GST_STATE_READY<<4) | GST_STATE_NULL)
</MACRO>
<MACRO>
<NAME>GST_TYPE_ELEMENT</NAME>
#define GST_TYPE_ELEMENT \
  (gst_element_get_type())
</MACRO>
<MACRO>
<NAME>GST_ELEMENT</NAME>
#define GST_ELEMENT(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_ELEMENT,GstElement))
</MACRO>
<MACRO>
<NAME>GST_ELEMENT_CLASS</NAME>
#define GST_ELEMENT_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ELEMENT,GstElementClass))
</MACRO>
<MACRO>
<NAME>GST_IS_ELEMENT</NAME>
#define GST_IS_ELEMENT(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_ELEMENT))
</MACRO>
<MACRO>
<NAME>GST_IS_ELEMENT_CLASS</NAME>
#define GST_IS_ELEMENT_CLASS(klass) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ELEMENT))
</MACRO>
<ENUM>
<NAME>GstElementFlags</NAME>
typedef enum {
  /* element is complex (for some def.) and generally require a cothread */
  GST_ELEMENT_COMPLEX		= GST_OBJECT_FLAG_LAST,
  /* input and output pads aren't directly coupled to each other
     examples: queues, multi-output async readers, etc. */
  GST_ELEMENT_DECOUPLED,
  /* this element should be placed in a thread if at all possible */
  GST_ELEMENT_THREAD_SUGGESTED,
  /* this element is incable of seeking (FIXME: does this apply to filters?) */
  GST_ELEMENT_NO_SEEK,

  /* there is a new loopfunction ready for placement */
  GST_ELEMENT_NEW_LOOPFUNC,
  /* the cothread holding this element needs to be stopped */
  GST_ELEMENT_COTHREAD_STOPPING,
  /* the element has to be scheduled as a cothread for any sanity */
  GST_ELEMENT_USE_COTHREAD,

  /* use some padding for future expansion */
  GST_ELEMENT_FLAG_LAST		= GST_OBJECT_FLAG_LAST + 8,
} GstElementFlags;
</ENUM>
<MACRO>
<NAME>GST_ELEMENT_IS_THREAD_SUGGESTED</NAME>
#define GST_ELEMENT_IS_THREAD_SUGGESTED(obj)	(GST_FLAG_IS_SET(obj,GST_ELEMENT_THREAD_SUGGESTED))
</MACRO>
<MACRO>
<NAME>GST_ELEMENT_IS_COTHREAD_STOPPING</NAME>
#define GST_ELEMENT_IS_COTHREAD_STOPPING(obj)	(GST_FLAG_IS_SET(obj,GST_ELEMENT_COTHREAD_STOPPING))
</MACRO>
<STRUCT>
<NAME>GstElement</NAME>
</STRUCT>
<STRUCT>
<NAME>GstElementClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstElementDetails</NAME>
</STRUCT>
<STRUCT>
<NAME>GstElementFactory</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GstElementLoopFunction</NAME>
<RETURNS>void </RETURNS>
GstElement *element
</USER_FUNCTION>
<STRUCT>
<NAME>GstElement</NAME>
struct GstElement {
  GstObject object;

  gchar *name;

  guint8 current_state;
  guint8 pending_state;

  GstElementLoopFunction loopfunc;
  cothread_state *threadstate;

  guint16 numpads;
  guint16 numsrcpads;
  guint16 numsinkpads;
  GList *pads;

  GstElement *manager;
};
</STRUCT>
<STRUCT>
<NAME>GstElementDetails</NAME>
struct GstElementDetails {
  gchar *longname;              /* long, english name */
  gchar *klass;                 /* type of element, kinda */
  gchar *description;           /* insights of one form or another */
  gchar *version;               /* version of the element */
  gchar *author;                /* who wrote this thing? */
  gchar *copyright;             /* copyright details (year, etc.) */
};
</STRUCT>
<STRUCT>
<NAME>GstElementFactory</NAME>
struct GstElementFactory {
  gchar *name;			/* name of element */
  GtkType type;			/* unique GtkType of element */

  GstElementDetails *details;	/* pointer to details struct */

  GList *padtemplates;
};
</STRUCT>
<FUNCTION>
<NAME>gst_element_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_element_new</NAME>
<RETURNS>GstElement *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>gst_element_destroy</NAME>
#define 		gst_element_destroy(element) 	gst_object_destroy (GST_OBJECT (element))
</MACRO>
<FUNCTION>
<NAME>gst_element_set_loop_function</NAME>
<RETURNS>void  </RETURNS>
GstElement *element,GstElementLoopFunction loop
</FUNCTION>
<FUNCTION>
<NAME>gst_element_set_name</NAME>
<RETURNS>void  </RETURNS>
GstElement *element, gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_element_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_element_set_manager</NAME>
<RETURNS>void  </RETURNS>
GstElement *element, GstElement *manager
</FUNCTION>
<FUNCTION>
<NAME>gst_element_get_manager</NAME>
<RETURNS>GstElement *</RETURNS>
GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_element_add_pad</NAME>
<RETURNS>void  </RETURNS>
GstElement *element, GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_element_get_pad</NAME>
<RETURNS>GstPad *</RETURNS>
GstElement *element, gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_element_get_pad_list</NAME>
<RETURNS>GList *</RETURNS>
GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_element_get_padtemplate_list</NAME>
<RETURNS>GList *</RETURNS>
GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_element_add_ghost_pad</NAME>
<RETURNS>void  </RETURNS>
GstElement *element, GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_element_connect</NAME>
<RETURNS>void  </RETURNS>
GstElement *src, gchar *srcpadname,GstElement *dest, gchar *destpadname
</FUNCTION>
<FUNCTION>
<NAME>gst_element_set_state</NAME>
<RETURNS>gint  </RETURNS>
GstElement *element, GstElementState state
</FUNCTION>
<FUNCTION>
<NAME>gst_element_error</NAME>
<RETURNS>void  </RETURNS>
GstElement *element, gchar *error
</FUNCTION>
<FUNCTION>
<NAME>gst_element_get_factory</NAME>
<RETURNS>GstElementFactory *</RETURNS>
GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_element_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
GstElement *element, xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_element_load_thyself</NAME>
<RETURNS>GstElement *</RETURNS>
xmlNodePtr parent, GHashTable *elements
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_new</NAME>
<RETURNS>GstElementFactory *</RETURNS>
gchar *name,GtkType type,GstElementDetails *details
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_destroy</NAME>
<RETURNS>void  </RETURNS>
GstElementFactory *elementfactory
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_add_padtemplate</NAME>
<RETURNS>void  </RETURNS>
GstElementFactory *elementfactory,GstPadTemplate *temp
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_find</NAME>
<RETURNS>GstElementFactory *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_get_list</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_can_src_caps</NAME>
<RETURNS>gboolean 	</RETURNS>
GstElementFactory *factory,GstCaps *caps
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_can_sink_caps</NAME>
<RETURNS>gboolean 	</RETURNS>
GstElementFactory *factory,GstCaps *caps
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_create</NAME>
<RETURNS>GstElement *</RETURNS>
GstElementFactory *factory,gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_make</NAME>
<RETURNS>GstElement *</RETURNS>
gchar *factoryname, gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
GstElementFactory *factory, xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_load_thyself</NAME>
<RETURNS>GstElementFactory *</RETURNS>
xmlNodePtr parent
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FILTER</NAME>
#define GST_TYPE_FILTER \
  (gst_filter_get_type())
</MACRO>
<MACRO>
<NAME>GST_FILTER</NAME>
#define GST_FILTER(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_FILTER,GstFilter))
</MACRO>
<MACRO>
<NAME>GST_FILTER_CLASS</NAME>
#define GST_FILTER_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FILTER,GstFilterClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FILTER</NAME>
#define GST_IS_FILTER(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_FILTER))
</MACRO>
<MACRO>
<NAME>GST_IS_FILTER_CLASS</NAME>
#define GST_IS_FILTER_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FILTER))
</MACRO>
<STRUCT>
<NAME>GstFilter</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFilterClass</NAME>
</STRUCT>
<MACRO>
<NAME>GST_FILTER_FLAG_LAST</NAME>
#define GST_FILTER_FLAG_LAST GST_ELEMENT_FLAG_LAST
</MACRO>
<STRUCT>
<NAME>GstFilter</NAME>
struct GstFilter {
  GstElement element;
};
</STRUCT>
<FUNCTION>
<NAME>gst_filter_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_filter_new</NAME>
<RETURNS>GstElement *</RETURNS>
gchar *name
</FUNCTION>
<MACRO>
<NAME>GST_SHOW_INFO</NAME>
#define GST_SHOW_INFO
</MACRO>
<MACRO>
<NAME>gst_info</NAME>
#define gst_info(format,args...) fprintf(stderr,format,##args)
</MACRO>
<MACRO>
<NAME>gst_info</NAME>
#define gst_info(format,args...)
</MACRO>
<MACRO>
<NAME>GST_META</NAME>
#define GST_META(meta) ((GstMeta *)(meta))
</MACRO>
<MACRO>
<NAME>GST_META_FLAGS</NAME>
#define GST_META_FLAGS(meta) \
  (GST_META(meta)->flags)
</MACRO>
<MACRO>
<NAME>GST_META_FLAG_IS_SET</NAME>
#define GST_META_FLAG_IS_SET(meta,flag) \
  (GST_META_FLAGS(meta) & (flag))
</MACRO>
<MACRO>
<NAME>GST_META_FLAG_SET</NAME>
#define GST_META_FLAG_SET(meta,flag) \
  G_STMT_START{ (GST_META_FLAGS(meta) |= (flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_META_FLAG_UNSET</NAME>
#define GST_META_FLAG_UNSET(meta,flag) \
  G_STMT_START{ (GST_META_FLAGS(meta) &= ~(flag)); }G_STMT_END
</MACRO>
<ENUM>
<NAME>GstMetaFlags</NAME>
typedef enum {
  GST_META_FREEABLE             = 1 << 0,
} GstMetaFlags;
</ENUM>
<STRUCT>
<NAME>GstMeta</NAME>
</STRUCT>
<STRUCT>
<NAME>GstMeta</NAME>
struct GstMeta {
  /* locking */
  GMutex *lock;

  /* refcounting */
#ifdef HAVE_ATOMIC_H
  atomic_t refcount;
#else
  int refcount;
#endif

  guint16 type;
  guint16 flags;

  void *data;
  guint16 size;
};
</STRUCT>
<FUNCTION>
<NAME>gst_meta_new_size</NAME>
<RETURNS>GstMeta *</RETURNS>
gint size
</FUNCTION>
<MACRO>
<NAME>gst_meta_new</NAME>
#define 	gst_meta_new(type) 	(type *)gst_meta_new_size(sizeof(type))
</MACRO>
<FUNCTION>
<NAME>gst_meta_ref</NAME>
<RETURNS>void  </RETURNS>
GstMeta *meta
</FUNCTION>
<FUNCTION>
<NAME>gst_meta_unref</NAME>
<RETURNS>void  </RETURNS>
GstMeta *meta
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_OBJECT</NAME>
#define GST_TYPE_OBJECT \
  (gst_object_get_type())
</MACRO>
<MACRO>
<NAME>GST_OBJECT</NAME>
#define GST_OBJECT(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_OBJECT,GstObject))
</MACRO>
<MACRO>
<NAME>GST_OBJECT_CLASS</NAME>
#define GST_OBJECT_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_OBJECT,GstObjectClass))
</MACRO>
<MACRO>
<NAME>GST_IS_OBJECT</NAME>
#define GST_IS_OBJECT(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_OBJECT))
</MACRO>
<MACRO>
<NAME>GST_IS_OBJECT_CLASS</NAME>
#define GST_IS_OBJECT_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_OBJECT))
</MACRO>
<STRUCT>
<NAME>GstObject</NAME>
</STRUCT>
<STRUCT>
<NAME>GstObjectClass</NAME>
</STRUCT>
<MACRO>
<NAME>GST_OBJECT_FLAG_LAST</NAME>
#define GST_OBJECT_FLAG_LAST 4
</MACRO>
<STRUCT>
<NAME>GstObject</NAME>
struct GstObject {
  GtkObject object;

  /* have to have a refcount for the object */
#ifdef HAVE_ATOMIC_H
  atomic_t refcount;
#else
  int refcount;
#endif

  /* locking for all sorts of things (like the refcount) */
  GMutex *lock;

  /* this objects parent */
  GstObject *parent;
};
</STRUCT>
<MACRO>
<NAME>GST_FLAGS</NAME>
#define GST_FLAGS(obj)			GTK_OBJECT_FLAGS(obj)
</MACRO>
<MACRO>
<NAME>GST_FLAG_IS_SET</NAME>
#define GST_FLAG_IS_SET(obj,flag)	(GST_FLAGS (obj) & (1<<(flag)))
</MACRO>
<MACRO>
<NAME>GST_FLAG_SET</NAME>
#define GST_FLAG_SET(obj,flag)		G_STMT_START{ (GST_FLAGS (obj) |= (1<<(flag))); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_FLAG_UNSET</NAME>
#define GST_FLAG_UNSET(obj,flag)	G_STMT_START{ (GST_FLAGS (obj) &= ~(1<<(flag))); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_LOCK</NAME>
#define GST_LOCK(obj)		(g_mutex_lock(GST_OBJECT(obj)->lock))
</MACRO>
<MACRO>
<NAME>GST_TRYLOCK</NAME>
#define GST_TRYLOCK(obj)	(g_mutex_trylock(GST_OBJECT(obj)->lock))
</MACRO>
<MACRO>
<NAME>GST_UNLOCK</NAME>
#define GST_UNLOCK(obj)		(g_mutex_unlock(GST_OBJECT(obj)->lock))
</MACRO>
<FUNCTION>
<NAME>gst_object_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_object_new</NAME>
<RETURNS>GstObject *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_object_set_parent</NAME>
<RETURNS>void  </RETURNS>
GstObject *object,GstObject *parent
</FUNCTION>
<FUNCTION>
<NAME>gst_object_get_parent</NAME>
<RETURNS>GstObject *</RETURNS>
GstObject *object
</FUNCTION>
<FUNCTION>
<NAME>gst_object_unparent</NAME>
<RETURNS>void  </RETURNS>
GstObject *object
</FUNCTION>
<MACRO>
<NAME>gst_object_ref</NAME>
#define 	gst_object_ref(object) 		gtk_object_ref(GTK_OBJECT(object));
</MACRO>
<MACRO>
<NAME>gst_object_unref</NAME>
#define 	gst_object_unref(object) 	gtk_object_unref(GTK_OBJECT(object));
</MACRO>
<MACRO>
<NAME>gst_object_sink</NAME>
#define 	gst_object_sink(object) 	gtk_object_sink(GTK_OBJECT(object));
</MACRO>
<MACRO>
<NAME>gst_object_destroy</NAME>
#define 	gst_object_destroy(object) 	gtk_object_destroy(GTK_OBJECT(object))
</MACRO>
<MACRO>
<NAME>GST_TYPE_PAD</NAME>
#define GST_TYPE_PAD                 	(gst_pad_get_type ())
</MACRO>
<MACRO>
<NAME>GST_PAD</NAME>
#define GST_PAD(obj)                 	(GTK_CHECK_CAST ((obj), GST_TYPE_PAD,GstPad))
</MACRO>
<MACRO>
<NAME>GST_PAD_CLASS</NAME>
#define GST_PAD_CLASS(klass)         	(GTK_CHECK_CLASS_CAST ((klass), GST_TYPE_PAD,GstPadClass))
</MACRO>
<MACRO>
<NAME>GST_IS_PAD</NAME>
#define GST_IS_PAD(obj)              	(GTK_CHECK_TYPE ((obj), GST_TYPE_PAD))
</MACRO>
<MACRO>
<NAME>GST_IS_PAD_CLASS</NAME>
#define GST_IS_PAD_CLASS(obj)        	(GTK_CHECK_CLASS_TYPE ((klass), GST_TYPE_PAD))
</MACRO>
<MACRO>
<NAME>GST_PAD_CONNECTED</NAME>
#define GST_PAD_CONNECTED(pad) 		((pad) && (pad)->peer != NULL)
</MACRO>
<MACRO>
<NAME>GST_PAD_CAN_PULL</NAME>
#define GST_PAD_CAN_PULL(pad) 		((pad) && (pad)->pullfunc != NULL)
</MACRO>
<STRUCT>
<NAME>GstPad</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPadClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPadTemplate</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPadTemplateClass</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GstPadChainFunction</NAME>
<RETURNS>void </RETURNS>
GstPad *pad,GstBuffer *buf
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstPadGetFunction</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstPad *pad
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstPadGetRegionFunction</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstPad *pad, gulong offset, gulong size
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstPadQoSFunction</NAME>
<RETURNS>void </RETURNS>
GstPad *pad, glong qos_message
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstPadPushFunction</NAME>
<RETURNS>void </RETURNS>
GstPad *pad, GstBuffer *buf
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstPadPullFunction</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstPad *pad
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstPadPullRegionFunction</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstPad *pad, gulong offset, gulong size
</USER_FUNCTION>
<ENUM>
<NAME>GstPadDirection</NAME>
typedef enum {
  GST_PAD_UNKNOWN,
  GST_PAD_SRC,
  GST_PAD_SINK,
} GstPadDirection;
</ENUM>
<ENUM>
<NAME>GstPadFlags</NAME>
typedef enum {
  GST_PAD_DISABLED		= GST_OBJECT_FLAG_LAST,
  GST_PAD_EOS,

  GST_PAD_FLAG_LAST		= GST_OBJECT_FLAG_LAST + 4,
} GstPadFlags;
</ENUM>
<STRUCT>
<NAME>GstPad</NAME>
struct GstPad {
  GstObject object;

  gchar *name;
  GstCaps *caps;

  cothread_state *threadstate;

  GstPadDirection direction;

  GstPad *peer;

  GstBuffer *bufpen;

  GstPadChainFunction chainfunc;
  GstPadGetFunction getfunc;
  GstPadGetRegionFunction getregionfunc;
  GstPadQoSFunction qosfunc;

  GstPadPushFunction pushfunc;
  GstPadPullFunction pullfunc;
  GstPadPullRegionFunction pullregionfunc;

  GstObject *parent;
  GList *ghostparents;

  GstPadTemplate *padtemplate;	/* the template for this pad */
};
</STRUCT>
<MACRO>
<NAME>GST_TYPE_PADTEMPLATE</NAME>
#define GST_TYPE_PADTEMPLATE           	(gst_padtemplate_get_type ())
</MACRO>
<MACRO>
<NAME>GST_PADTEMPLATE</NAME>
#define GST_PADTEMPLATE(obj)           	(GTK_CHECK_CAST ((obj), GST_TYPE_PADTEMPLATE,GstPad))
</MACRO>
<MACRO>
<NAME>GST_PADTEMPLATE_CLASS</NAME>
#define GST_PADTEMPLATE_CLASS(klass)   	(GTK_CHECK_CLASS_CAST ((klass), GST_TYPE_PADTEMPLATE,GstPadClass))
</MACRO>
<MACRO>
<NAME>GST_IS_PADTEMPLATE</NAME>
#define GST_IS_PADTEMPLATE(obj)        	(GTK_CHECK_TYPE ((obj), GST_TYPE_PADTEMPLATE))
</MACRO>
<MACRO>
<NAME>GST_IS_PADTEMPLATE_CLASS</NAME>
#define GST_IS_PADTEMPLATE_CLASS(obj)  	(GTK_CHECK_CLASS_TYPE ((klass), GST_TYPE_PADTEMPLATE))
</MACRO>
<ENUM>
<NAME>GstPadPresence</NAME>
typedef enum {
  GST_PAD_ALWAYS,
  GST_PAD_SOMETIMES,
} GstPadPresence;
</ENUM>
<STRUCT>
<NAME>GstPadTemplate</NAME>
struct GstPadTemplate {
  GstObject 	  object;

  gchar           *name_template;
  GstPadDirection direction;
  GstPadPresence  presence;
  GstCaps  	  *caps;
};
</STRUCT>
<TYPEDEF>
<NAME>GstPadFactoryEntry</NAME>
typedef gpointer GstPadFactoryEntry;
</TYPEDEF>
<TYPEDEF>
<NAME>GstPadFactory[]</NAME>
typedef GstPadFactoryEntry GstPadFactory[];
</TYPEDEF>
<MACRO>
<NAME>GST_PAD_FACTORY_ALWAYS</NAME>
#define GST_PAD_FACTORY_ALWAYS 		GINT_TO_POINTER(GST_PAD_ALWAYS)
</MACRO>
<MACRO>
<NAME>GST_PAD_FACTORY_SOMETIMES</NAME>
#define GST_PAD_FACTORY_SOMETIMES 	GINT_TO_POINTER(GST_PAD_SOMETIMES)
</MACRO>
<MACRO>
<NAME>GST_PAD_FACTORY_SRC</NAME>
#define GST_PAD_FACTORY_SRC	 	GINT_TO_POINTER(GST_PAD_SRC)
</MACRO>
<MACRO>
<NAME>GST_PAD_FACTORY_SINK</NAME>
#define GST_PAD_FACTORY_SINK 		GINT_TO_POINTER(GST_PAD_SINK)
</MACRO>
<FUNCTION>
<NAME>gst_pad_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_new</NAME>
<RETURNS>GstPad *</RETURNS>
gchar *name, GstPadDirection direction
</FUNCTION>
<MACRO>
<NAME>gst_pad_destroy</NAME>
#define 		gst_pad_destroy(pad) 		gst_object_destroy (GST_OBJECT (pad))
</MACRO>
<FUNCTION>
<NAME>gst_pad_new_from_template</NAME>
<RETURNS>GstPad *</RETURNS>
GstPadTemplate *temp, gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_get_direction</NAME>
<RETURNS>GstPadDirection  </RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_chain_function</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstPadChainFunction chain
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_get_function</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstPadGetFunction get
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_getregion_function</NAME>
<RETURNS>void 	</RETURNS>
GstPad *pad, GstPadGetRegionFunction getregion
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_qos_function</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstPadQoSFunction qos
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_caps</NAME>
<RETURNS>void 	</RETURNS>
GstPad *pad, GstCaps *caps
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_get_caps</NAME>
<RETURNS>GstCaps *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_name</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_parent</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstObject *parent
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_get_parent</NAME>
<RETURNS>GstObject *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_add_ghost_parent</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstObject *parent
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_remove_ghost_parent</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstObject *parent
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_get_ghost_parents</NAME>
<RETURNS>GList *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_get_peer</NAME>
<RETURNS>GstPad *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_connect</NAME>
<RETURNS>void  </RETURNS>
GstPad *srcpad, GstPad *sinkpad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_disconnect</NAME>
<RETURNS>void  </RETURNS>
GstPad *srcpad, GstPad *sinkpad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_push</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstBuffer *buffer
</FUNCTION>
<MACRO>
<NAME>gst_pad_push</NAME>
#define gst_pad_push(pad,buf) G_STMT_START{ \
  if ((pad)->peer->pushfunc) ((pad)->peer->pushfunc)((pad)->peer,(buf)); \
}G_STMT_END
</MACRO>
<FUNCTION>
<NAME>gst_pad_pull</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_pull_region</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstPad *pad, gulong offset, gulong size
</FUNCTION>
<MACRO>
<NAME>gst_pad_pull</NAME>
#define gst_pad_pull(pad) \
  (((pad)->peer->pullfunc) ? ((pad)->peer->pullfunc)((pad)->peer) : NULL)
</MACRO>
<MACRO>
<NAME>gst_pad_pullregion</NAME>
#define gst_pad_pullregion(pad,offset,size) \
  (((pad)->peer->pullregionfunc) ? ((pad)->peer->pullregionfunc)((pad)->peer,(offset),(size)) : NULL)
</MACRO>
<FUNCTION>
<NAME>gst_pad_handle_qos</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, glong qos_message
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
GstPad *pad, xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_load_and_connect</NAME>
<RETURNS>void  </RETURNS>
xmlNodePtr parent, GstObject *element, GHashTable *elements
</FUNCTION>
<FUNCTION>
<NAME>gst_padtemplate_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_padtemplate_new</NAME>
<RETURNS>GstPadTemplate *</RETURNS>
GstPadFactory *factory
</FUNCTION>
<FUNCTION>
<NAME>gst_padtemplate_create</NAME>
<RETURNS>GstPadTemplate *</RETURNS>
gchar *name_template,GstPadDirection direction, GstPadPresence presence,GstCaps *caps
</FUNCTION>
<FUNCTION>
<NAME>gst_padtemplate_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
GstPadTemplate *pad, xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_padtemplate_load_thyself</NAME>
<RETURNS>GstPadTemplate *</RETURNS>
xmlNodePtr parent
</FUNCTION>
<VARIABLE>
<NAME>gst_pipeline_details</NAME>
extern GstElementDetails gst_pipeline_details;
</VARIABLE>
<MACRO>
<NAME>GST_TYPE_PIPELINE</NAME>
#define GST_TYPE_PIPELINE \
  (gst_pipeline_get_type())
</MACRO>
<MACRO>
<NAME>GST_PIPELINE</NAME>
#define GST_PIPELINE(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_PIPELINE,GstPipeline))
</MACRO>
<MACRO>
<NAME>GST_PIPELINE_CLASS</NAME>
#define GST_PIPELINE_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_PIPELINE,GstPipelineClass))
</MACRO>
<MACRO>
<NAME>GST_IS_PIPELINE</NAME>
#define GST_IS_PIPELINE(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_PIPELINE))
</MACRO>
<MACRO>
<NAME>GST_IS_PIPELINE_CLASS</NAME>
#define GST_IS_PIPELINE_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_PIPELINE))
</MACRO>
<STRUCT>
<NAME>GstPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPipelineClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPipeline</NAME>
struct GstPipeline {
  GstBin bin;

  GstElement *src;         /* we only allow one src element */
  GList      *sinks;	   /* and multiple sinks */
};
</STRUCT>
<FUNCTION>
<NAME>gst_pipeline_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_pipeline_new</NAME>
<RETURNS>GstElement *</RETURNS>
guchar *name
</FUNCTION>
<MACRO>
<NAME>gst_pipeline_destroy</NAME>
#define 	gst_pipeline_destroy(pipeline) 	gst_object_destroy(GST_OBJECT(pipeline))
</MACRO>
<FUNCTION>
<NAME>gst_pipeline_add_src</NAME>
<RETURNS>void  </RETURNS>
GstPipeline *pipeline, GstElement *src
</FUNCTION>
<FUNCTION>
<NAME>gst_pipeline_add_sink</NAME>
<RETURNS>void  </RETURNS>
GstPipeline *pipeline, GstElement *sink
</FUNCTION>
<FUNCTION>
<NAME>gst_pipeline_autoplug</NAME>
<RETURNS>gboolean  </RETURNS>
GstPipeline *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gst_pipeline_iterate</NAME>
<RETURNS>void  </RETURNS>
GstPipeline *pipeline
</FUNCTION>
<STRUCT>
<NAME>GstPlugin</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPluginElement</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPlugin</NAME>
struct GstPlugin {
  gchar *name;			/* name of the plugin */
  gchar *longname;		/* long name of plugin */
  gchar *filename;		/* filename it came from */

  GList *types;			/* list of types provided */
  GList *elements;		/* list of elements provided */

  gboolean loaded;              /* if the plugin is in memory */
};
</STRUCT>
<USER_FUNCTION>
<NAME>GstPluginInitFunc</NAME>
<RETURNS>GstPlugin *</RETURNS>
GModule *module
</USER_FUNCTION>
<FUNCTION>
<NAME>gst_plugin_new</NAME>
<RETURNS>GstPlugin *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_set_longname</NAME>
<RETURNS>void  </RETURNS>
GstPlugin *plugin, gchar *longname
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_load_all</NAME>
<RETURNS>void  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_load</NAME>
<RETURNS>gboolean  </RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_load_absolute</NAME>
<RETURNS>gboolean  </RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_library_load</NAME>
<RETURNS>gboolean  </RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_add_factory</NAME>
<RETURNS>void  </RETURNS>
GstPlugin *plugin, GstElementFactory *factory
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_add_type</NAME>
<RETURNS>void  </RETURNS>
GstPlugin *plugin, GstTypeFactory *factory
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_find</NAME>
<RETURNS>GstPlugin *</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_get_list</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_find_elementfactory</NAME>
<RETURNS>GstElementFactory *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_load_elementfactory</NAME>
<RETURNS>GstElementFactory *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_load_typefactory</NAME>
<RETURNS>void  </RETURNS>
gchar *mime
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_load_thyself</NAME>
<RETURNS>void  </RETURNS>
xmlNodePtr parent
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_SINK</NAME>
#define GST_TYPE_SINK \
  (gst_sink_get_type())
</MACRO>
<MACRO>
<NAME>GST_SINK</NAME>
#define GST_SINK(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_SINK,GstSink))
</MACRO>
<MACRO>
<NAME>GST_SINK_CLASS</NAME>
#define GST_SINK_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SINK,GstSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_SINK</NAME>
#define GST_IS_SINK(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_SINK))
</MACRO>
<MACRO>
<NAME>GST_IS_SINK_CLASS</NAME>
#define GST_IS_SINK_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SINK))
</MACRO>
<STRUCT>
<NAME>GstSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstSinkClass</NAME>
</STRUCT>
<MACRO>
<NAME>GST_SINK_FLAG_LAST</NAME>
#define GST_SINK_FLAG_LAST GST_ELEMENT_FLAG_LAST
</MACRO>
<STRUCT>
<NAME>GstSink</NAME>
struct GstSink {
  GstElement element;
};
</STRUCT>
<FUNCTION>
<NAME>gst_sink_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_sink_new</NAME>
<RETURNS>GstObject *</RETURNS>
gchar *name
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_SRC</NAME>
#define GST_TYPE_SRC \
  (gst_src_get_type())
</MACRO>
<MACRO>
<NAME>GST_SRC</NAME>
#define GST_SRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_SRC,GstSrc))
</MACRO>
<MACRO>
<NAME>GST_SRC_CLASS</NAME>
#define GST_SRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SRC,GstSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_SRC</NAME>
#define GST_IS_SRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_SRC))
</MACRO>
<MACRO>
<NAME>GST_IS_SRC_CLASS</NAME>
#define GST_IS_SRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SRC))
</MACRO>
<ENUM>
<NAME>GstSrcFlags</NAME>
typedef enum {
  GST_SRC_ASYNC		= GST_ELEMENT_FLAG_LAST,

  GST_SRC_FLAG_LAST	= GST_ELEMENT_FLAG_LAST +2,
} GstSrcFlags;
</ENUM>
<STRUCT>
<NAME>GstSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstSrcClass</NAME>
</STRUCT>
<MACRO>
<NAME>GST_SRC_IS_ASYNC</NAME>
#define GST_SRC_IS_ASYNC(obj) (GST_FLAG_IS_SET(obj,GST_SRC_ASYNC))
</MACRO>
<STRUCT>
<NAME>GstSrc</NAME>
struct GstSrc {
  GstElement			element;
};
</STRUCT>
<FUNCTION>
<NAME>gst_src_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_src_signal_eos</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_TEE</NAME>
#define GST_TYPE_TEE \
  (gst_tee_get_type())
</MACRO>
<MACRO>
<NAME>GST_TEE</NAME>
#define GST_TEE(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_TEE,GstTee))
</MACRO>
<MACRO>
<NAME>GST_TEE_CLASS</NAME>
#define GST_TEE_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_TEE,GstTeeClass))
</MACRO>
<MACRO>
<NAME>GST_IS_TEE</NAME>
#define GST_IS_TEE(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_TEE))
</MACRO>
<MACRO>
<NAME>GST_IS_TEE_CLASS</NAME>
#define GST_IS_TEE_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_TEE))
</MACRO>
<STRUCT>
<NAME>GstTee</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTeeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTee</NAME>
struct GstTee {
  GstFilter filter;

  GstPad *sinkpad;

  gint numsrcpads;
  GSList *srcpads;
};
</STRUCT>
<FUNCTION>
<NAME>gst_tee_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_tee_new</NAME>
<RETURNS>GstElement *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_tee_new_pad</NAME>
<RETURNS>gchar *</RETURNS>
GstTee *tee
</FUNCTION>
<FUNCTION>
<NAME>gst_tee_chain</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad, GstBuffer *buf
</FUNCTION>
<VARIABLE>
<NAME>gst_thread_details</NAME>
extern GstElementDetails gst_thread_details;
</VARIABLE>
<ENUM>
<NAME>GstThreadState</NAME>
typedef enum {
  GST_THREAD_CREATE		= GST_BIN_FLAG_LAST,
  GST_THREAD_STATE_SPINNING,
  GST_THREAD_STATE_REAPING,

  /* padding */
  GST_THREAD_FLAG_LAST 		= GST_BIN_FLAG_LAST + 4,
} GstThreadState;
</ENUM>
<MACRO>
<NAME>GST_TYPE_THREAD</NAME>
#define GST_TYPE_THREAD \
  (gst_thread_get_type())
</MACRO>
<MACRO>
<NAME>GST_THREAD</NAME>
#define GST_THREAD(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_THREAD,GstThread))
</MACRO>
<MACRO>
<NAME>GST_THREAD_CLASS</NAME>
#define GST_THREAD_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_THREAD,GstThreadClass))
</MACRO>
<MACRO>
<NAME>GST_IS_THREAD</NAME>
#define GST_IS_THREAD(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_THREAD))
</MACRO>
<MACRO>
<NAME>GST_IS_THREAD_CLASS</NAME>
#define GST_IS_THREAD_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_THREAD))
</MACRO>
<STRUCT>
<NAME>GstThread</NAME>
</STRUCT>
<STRUCT>
<NAME>GstThreadClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstThread</NAME>
struct GstThread {
  GstBin bin;

  pthread_t thread_id;		/* id of the thread, if any */
  GMutex *lock;			/* thread lock/condititon pair... */
  GCond *cond;			/* used to control the thread */
};
</STRUCT>
<FUNCTION>
<NAME>gst_thread_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_thread_new</NAME>
<RETURNS>GstElement *</RETURNS>
guchar *name
</FUNCTION>
<STRUCT>
<NAME>GstTrace</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTraceEntry</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTrace</NAME>
struct GstTrace {
  /* where this trace is going */
  gchar *filename;
  int fd;

  /* current buffer, size, head offset */
  GstTraceEntry *buf;
  gint bufsize;
  gint bufoffset;
};
</STRUCT>
<STRUCT>
<NAME>GstTraceEntry</NAME>
struct GstTraceEntry {
  guint64 timestamp;
  guint32 sequence;
  guint32 data;
  gchar message[112];
};
</STRUCT>
<FUNCTION>
<NAME>gst_trace_new</NAME>
<RETURNS>GstTrace *</RETURNS>
guchar *filename, gint size
</FUNCTION>
<FUNCTION>
<NAME>gst_trace_destroy</NAME>
<RETURNS>void  </RETURNS>
GstTrace *trace
</FUNCTION>
<FUNCTION>
<NAME>gst_trace_flush</NAME>
<RETURNS>void  </RETURNS>
GstTrace *trace
</FUNCTION>
<MACRO>
<NAME>gst_trace_get_size</NAME>
#define 	gst_trace_get_size(trace) 	((trace)->bufsize)
</MACRO>
<MACRO>
<NAME>gst_trace_get_offset</NAME>
#define 	gst_trace_get_offset(trace) 	((trace)->bufoffset)
</MACRO>
<MACRO>
<NAME>gst_trace_get_remaining</NAME>
#define 	gst_trace_get_remaining(trace) 	((trace)->bufsize - (trace)->bufoffset)
</MACRO>
<FUNCTION>
<NAME>gst_trace_set_default</NAME>
<RETURNS>void  </RETURNS>
GstTrace *trace
</FUNCTION>
<FUNCTION>
<NAME>gst_trace_read_tsc</NAME>
<RETURNS>void  </RETURNS>
guint64 *dst
</FUNCTION>
<MACRO>
<NAME>TRACE_ENABLE</NAME>
#define TRACE_ENABLE
</MACRO>
<MACRO>
<NAME>gst_trace_add_entry</NAME>
#define gst_trace_add_entry(trace,seq,data,msg) \
  if (_gst_trace_on) { \
    _gst_trace_add_entry(trace,(guint32)seq,(guint32)data,msg); \
  }
</MACRO>
<MACRO>
<NAME>gst_trace_add_entry</NAME>
#define gst_trace_add_entry(trace,seq,data,msg)
</MACRO>
<USER_FUNCTION>
<NAME>GstTypeFindFunc</NAME>
<RETURNS>GstCaps *</RETURNS>
GstBuffer *buf,gpointer priv
</USER_FUNCTION>
<STRUCT>
<NAME>GstType</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTypeFactory</NAME>
</STRUCT>
<STRUCT>
<NAME>GstType</NAME>
struct GstType {
  guint16 id;			/* type id (assigned) */

  gchar *mime;			/* MIME type */
  gchar *exts;			/* space-delimited list of extensions */

  GSList *typefindfuncs;	/* typefind functions */

};
</STRUCT>
<STRUCT>
<NAME>GstTypeFactory</NAME>
struct GstTypeFactory {
  gchar *mime;
  gchar *exts;
  GstTypeFindFunc typefindfunc;
};
</STRUCT>
<FUNCTION>
<NAME>gst_type_register</NAME>
<RETURNS>guint16  </RETURNS>
GstTypeFactory *factory
</FUNCTION>
<FUNCTION>
<NAME>gst_type_find_by_mime</NAME>
<RETURNS>guint16  </RETURNS>
gchar *mime
</FUNCTION>
<FUNCTION>
<NAME>gst_type_find_by_ext</NAME>
<RETURNS>guint16  </RETURNS>
gchar *ext
</FUNCTION>
<FUNCTION>
<NAME>gst_type_find_by_id</NAME>
<RETURNS>GstType *</RETURNS>
guint16 id
</FUNCTION>
<FUNCTION>
<NAME>gst_type_get_list</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_typefactory_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
GstTypeFactory *factory, xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_typefactory_load_thyself</NAME>
<RETURNS>GstTypeFactory *</RETURNS>
xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_int_arg</NAME>
<RETURNS>gint  </RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_bool_arg</NAME>
<RETURNS>gboolean 	</RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_long_arg</NAME>
<RETURNS>glong  </RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_float_arg</NAME>
<RETURNS>gfloat  </RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_double_arg</NAME>
<RETURNS>gdouble  </RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_string_arg</NAME>
<RETURNS>guchar *</RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_pointer_arg</NAME>
<RETURNS>gpointer  </RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_widget_arg</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkObject *object, guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_dump_mem</NAME>
<RETURNS>void  </RETURNS>
guchar *mem, guint size
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_XML</NAME>
#define GST_TYPE_XML \
  (gst_object_get_type())
</MACRO>
<MACRO>
<NAME>GST_XML</NAME>
#define GST_XML(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_XML,GstXML))
</MACRO>
<MACRO>
<NAME>GST_XML_CLASS</NAME>
#define GST_XML_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_XML,GstXMLClass))
</MACRO>
<MACRO>
<NAME>GST_IS_XML</NAME>
#define GST_IS_XML(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_XML))
</MACRO>
<MACRO>
<NAME>GST_IS_XML_CLASS</NAME>
#define GST_IS_XML_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_XML))
</MACRO>
<STRUCT>
<NAME>GstXML</NAME>
</STRUCT>
<STRUCT>
<NAME>GstXMLClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstXML</NAME>
struct GstXML {
  GtkObject object;

  GHashTable *elements;
  GList      *topelements;
};
</STRUCT>
<FUNCTION>
<NAME>gst_xml_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_xml_write</NAME>
<RETURNS>xmlDocPtr  </RETURNS>
GstElement *element
</FUNCTION>
<FUNCTION>
<NAME>gst_xml_new</NAME>
<RETURNS>GstXML *</RETURNS>
const guchar *fname, const guchar *root
</FUNCTION>
<FUNCTION>
<NAME>gst_xml_get_element</NAME>
<RETURNS>GstElement *</RETURNS>
GstXML *xml, const guchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_xml_get_topelements</NAME>
<RETURNS>GList *</RETURNS>
GstXML *xml
</FUNCTION>
<STRUCT>
<NAME>GstCaps</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GstCapsFactoryEntry</NAME>
typedef gpointer GstCapsFactoryEntry;
</TYPEDEF>
<TYPEDEF>
<NAME>GstCapsFactory[]</NAME>
typedef GstCapsFactoryEntry GstCapsFactory[];
</TYPEDEF>
<STRUCT>
<NAME>GstCaps</NAME>
struct GstCaps {
  guint16 id;			/* type id (major type) */

  GstProps *properties;		/* properties for this capability */
};
</STRUCT>
<FUNCTION>
<NAME>gst_caps_new</NAME>
<RETURNS>GstCaps *</RETURNS>
gchar *mime
</FUNCTION>
<FUNCTION>
<NAME>gst_caps_new_with_props</NAME>
<RETURNS>GstCaps *</RETURNS>
gchar *mime, GstProps *props
</FUNCTION>
<FUNCTION>
<NAME>gst_caps_register</NAME>
<RETURNS>GstCaps *</RETURNS>
GstCapsFactory *factory
</FUNCTION>
<FUNCTION>
<NAME>gst_caps_set_props</NAME>
<RETURNS>GstCaps *</RETURNS>
GstCaps *caps, GstProps *props
</FUNCTION>
<FUNCTION>
<NAME>gst_caps_get_props</NAME>
<RETURNS>GstProps *</RETURNS>
GstCaps *caps
</FUNCTION>
<FUNCTION>
<NAME>gst_caps_check_compatibility</NAME>
<RETURNS>gboolean  </RETURNS>
GstCaps *fromcaps, GstCaps *tocaps
</FUNCTION>
<FUNCTION>
<NAME>gst_caps_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
GstCaps *caps, xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_caps_load_thyself</NAME>
<RETURNS>GstCaps *</RETURNS>
xmlNodePtr parent
</FUNCTION>
<MACRO>
<NAME>GST_BUFFER_POOL</NAME>
#define GST_BUFFER_POOL(buf) \
  ((GstBufferPool *)(buf))
</MACRO>
<STRUCT>
<NAME>GstBufferPool</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GstBufferPoolCreateFunction</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstBufferPool *pool, gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstBufferPoolDestroyFunction</NAME>
<RETURNS>void </RETURNS>
GstBufferPool *pool, GstBuffer *buffer, gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GstBufferPool</NAME>
struct GstBufferPool {
  /* will be called when a new buffer is to be created */
  GstBufferPoolCreateFunction new_buffer;
  /* user data to pass with the new_buffer function */
  gpointer new_user_data;

  gpointer destroy_user_data;
  GstBufferPoolDestroyFunction destroy_buffer;
};
</STRUCT>
<FUNCTION>
<NAME>gst_buffer_pool_new</NAME>
<RETURNS>GstBufferPool *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_pool_new_buffer</NAME>
<RETURNS>GstBuffer *</RETURNS>
GstBufferPool *pool
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_pool_destroy_buffer</NAME>
<RETURNS>void  </RETURNS>
GstBufferPool *pool, GstBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_pool_set_create_function</NAME>
<RETURNS>void  </RETURNS>
GstBufferPool *pool,GstBufferPoolCreateFunction create,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_pool_set_destroy_function</NAME>
<RETURNS>void  </RETURNS>
GstBufferPool *pool,GstBufferPoolDestroyFunction destroy,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_pool_destroy</NAME>
<RETURNS>void  </RETURNS>
GstBufferPool *pool
</FUNCTION>
<ENUM>
<NAME>GstCPUFlags</NAME>
typedef enum {
  GST_CPU_FLAG_MMX      = (1<<0),
  GST_CPU_FLAG_SSE      = (1<<1),
} GstCPUFlags;
</ENUM>
<FUNCTION>
<NAME>gst_cpu_get_flags</NAME>
<RETURNS>GstCPUFlags  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GET_SP</NAME>
#define GET_SP(target) \
  __asm__("movl %%esp, %0" : "=m"(target) : : "esp", "ebp");
</MACRO>
<MACRO>
<NAME>SET_SP</NAME>
#define SET_SP(source) \
  __asm__("movl %0, %%esp\n" : "=m"(thread->sp));
</MACRO>
<MACRO>
<NAME>JUMP</NAME>
#define JUMP(target) \
    __asm__("jmp " SYMBOL_NAME_STR(cothread_stub))
</MACRO>
<MACRO>
<NAME>SETUP_STACK</NAME>
#define SETUP_STACK(sp) do ; while(0)
</MACRO>
<MACRO>
<NAME>GET_SP</NAME>
#define GET_SP(target) \
    __asm__("stw 1,%0" : "=m"(target) : : "r1");
</MACRO>
<MACRO>
<NAME>SET_SP</NAME>
#define SET_SP(source) \
    __asm__("lwz 1,%0" : "=m"(source))
</MACRO>
<MACRO>
<NAME>JUMP</NAME>
#define JUMP(target) \
    __asm__("b " SYMBOL_NAME_STR(cothread_stub))
</MACRO>
<MACRO>
<NAME>SETUP_STACK</NAME>
#define SETUP_STACK(sp) \
    sp = ((unsigned long *)(sp)) - 4; \
    ((struct minimal_ppc_stackframe *)sp)->back_chain = 0;
</MACRO>
<MACRO>
<NAME>GST_TYPE_FILENAME</NAME>
#define GST_TYPE_FILENAME (gst_extra_get_filename_type())
</MACRO>
<FUNCTION>
<NAME>gst_extra_get_filename_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_DEBUG_ENABLED</NAME>
#define GST_DEBUG_ENABLED
</MACRO>
<MACRO>
<NAME>GST_DEBUG_PREFIX</NAME>
#define GST_DEBUG_PREFIX(format,args...) \
"DEBUG(%d:%d)" __PRETTY_FUNCTION__ ":%d" format , getpid() , cothread_getcurrent() , __LINE__ , ## args
</MACRO>
<USER_FUNCTION>
<NAME>_debug_function_f</NAME>
<RETURNS>void </RETURNS>

</USER_FUNCTION>
<MACRO>
<NAME>DEBUG</NAME>
#define DEBUG(format,args...) \
  (_debug_string != NULL) ? \
    fprintf(stderr,GST_DEBUG_PREFIX("%s: "format , _debug_string , ## args )) : \
    fprintf(stderr,GST_DEBUG_PREFIX(": "format , ## args ))
</MACRO>
<MACRO>
<NAME>DEBUG_NOPREFIX</NAME>
#define DEBUG_NOPREFIX(format,args...) fprintf(stderr,format , ## args )
</MACRO>
<MACRO>
<NAME>DEBUG_ENTER</NAME>
#define DEBUG_ENTER(format, args...) \
  fprintf(stderr,GST_DEBUG_PREFIX(format": entering\n" , ## args ))
</MACRO>
<MACRO>
<NAME>DEBUG_SET_STRING</NAME>
#define DEBUG_SET_STRING(format, args...) \
  gchar *_debug_string = g_strdup_printf(format , ## args )
</MACRO>
<MACRO>
<NAME>DEBUG_ENTER_STRING</NAME>
#define DEBUG_ENTER_STRING DEBUG_ENTER("%s",_debug_string)
</MACRO>
<MACRO>
<NAME>DEBUG_LEAVE</NAME>
#define DEBUG_LEAVE(format, args...) \
  if (_debug_string != NULL) g_free(_debug_string),\
    fprintf(stderr,GST_DEBUG_PREFIX(format": leaving\n" , ## args ))
</MACRO>
<MACRO>
<NAME>DEBUG_LEAVE_STRING</NAME>
#define DEBUG_LEAVE_STRING DEBUG_LEAVE("%s",_debug_string)
</MACRO>
<MACRO>
<NAME>DEBUG</NAME>
#define DEBUG(format, args...)
</MACRO>
<MACRO>
<NAME>DEBUG_NOPREFIX</NAME>
#define DEBUG_NOPREFIX(format, args...)
</MACRO>
<MACRO>
<NAME>DEBUG_ENTER</NAME>
#define DEBUG_ENTER(format, args...)
</MACRO>
<MACRO>
<NAME>DEBUG_LEAVE</NAME>
#define DEBUG_LEAVE(format, args...)
</MACRO>
<MACRO>
<NAME>DEBUG_SET_STRING</NAME>
#define DEBUG_SET_STRING(format, args...)
</MACRO>
<MACRO>
<NAME>DEBUG_ENTER_STRING</NAME>
#define DEBUG_ENTER_STRING
</MACRO>
<MACRO>
<NAME>GST_DEBUG_PAD_NAME</NAME>
#define GST_DEBUG_PAD_NAME(pad) \
  ((pad)->parent != NULL) ? gst_element_get_name(GST_ELEMENT((pad)->parent)) : "''", gst_pad_get_name(pad)
</MACRO>
<MACRO>
<NAME>GST_DEBUG_FUNCPTR</NAME>
#define GST_DEBUG_FUNCPTR(ptr) _gst_debug_register_funcptr((void *)(ptr), #ptr)
</MACRO>
<MACRO>
<NAME>GST_DEBUG_FUNCPTR_NAME</NAME>
#define GST_DEBUG_FUNCPTR_NAME(ptr) _gst_debug_nameof_funcptr((void *)ptr)
</MACRO>
<MACRO>
<NAME>GST_DEBUG_FUNCPTR</NAME>
#define GST_DEBUG_FUNCPTR(ptr) (ptr)
</MACRO>
<MACRO>
<NAME>GST_DEBUG_FUNCPTR_NAME</NAME>
#define GST_DEBUG_FUNCPTR_NAME(ptr) ""
</MACRO>
<STRUCT>
<NAME>GstProps</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GstPropsFactoryEntry</NAME>
typedef gpointer GstPropsFactoryEntry;
</TYPEDEF>
<TYPEDEF>
<NAME>GstPropsFactory[]</NAME>
typedef GstPropsFactoryEntry GstPropsFactory[];
</TYPEDEF>
<TYPEDEF>
<NAME>GstPropsListFactory[]</NAME>
typedef GstPropsFactory *GstPropsListFactory[];
</TYPEDEF>
<ENUM>
<NAME>GstPropsId</NAME>
typedef enum {
   GST_PROPS_END_ID_NUM = 0,
   GST_PROPS_LIST_ID_NUM,
   GST_PROPS_INT_ID_NUM,
   GST_PROPS_INT_RANGE_ID_NUM,
   GST_PROPS_FOURCC_ID_NUM,
   GST_PROPS_BOOL_ID_NUM,
} GstPropsId;
</ENUM>
<MACRO>
<NAME>GST_PROPS_LIST_ID</NAME>
#define GST_PROPS_LIST_ID GINT_TO_POINTER(GST_PROPS_LIST_ID_NUM)
</MACRO>
<MACRO>
<NAME>GST_PROPS_INT_ID</NAME>
#define GST_PROPS_INT_ID GINT_TO_POINTER(GST_PROPS_INT_ID_NUM)
</MACRO>
<MACRO>
<NAME>GST_PROPS_INT_RANGE_ID</NAME>
#define GST_PROPS_INT_RANGE_ID GINT_TO_POINTER(GST_PROPS_INT_RANGE_ID_NUM)
</MACRO>
<MACRO>
<NAME>GST_PROPS_FOURCC_ID</NAME>
#define GST_PROPS_FOURCC_ID GINT_TO_POINTER(GST_PROPS_FOURCC_ID_NUM)
</MACRO>
<MACRO>
<NAME>GST_PROPS_BOOL_ID</NAME>
#define GST_PROPS_BOOL_ID GINT_TO_POINTER(GST_PROPS_BOOL_ID_NUM)
</MACRO>
<MACRO>
<NAME>GST_PROPS_LIST</NAME>
#define GST_PROPS_LIST(a...) GST_PROPS_LIST_ID,##a,NULL
</MACRO>
<MACRO>
<NAME>GST_PROPS_INT</NAME>
#define GST_PROPS_INT(a) GST_PROPS_INT_ID,(GINT_TO_POINTER(a))
</MACRO>
<MACRO>
<NAME>GST_PROPS_INT_RANGE</NAME>
#define GST_PROPS_INT_RANGE(a,b) GST_PROPS_INT_RANGE_ID,(GINT_TO_POINTER(a)),(GINT_TO_POINTER(b))
</MACRO>
<MACRO>
<NAME>GST_PROPS_FOURCC</NAME>
#define GST_PROPS_FOURCC(a,b,c,d) GST_PROPS_FOURCC_ID,(GINT_TO_POINTER((a)|(b)<<8|(c)<<16|(d)<<24))
</MACRO>
<MACRO>
<NAME>GST_PROPS_FOURCC_INT</NAME>
#define GST_PROPS_FOURCC_INT(a) GST_PROPS_FOURCC_ID,(GINT_TO_POINTER(a))
</MACRO>
<MACRO>
<NAME>GST_PROPS_BOOLEAN</NAME>
#define GST_PROPS_BOOLEAN(a) GST_PROPS_BOOL_ID,(GINT_TO_POINTER(a))
</MACRO>
<STRUCT>
<NAME>GstProps</NAME>
struct GstProps {
  GSList *properties;		/* real properties for this property */
};
</STRUCT>
<FUNCTION>
<NAME>gst_props_register</NAME>
<RETURNS>GstProps *</RETURNS>
GstPropsFactory factory
</FUNCTION>
<FUNCTION>
<NAME>gst_props_new</NAME>
<RETURNS>GstProps *</RETURNS>
GstPropsFactoryEntry entry, ...
</FUNCTION>
<FUNCTION>
<NAME>gst_props_merge</NAME>
<RETURNS>GstProps *</RETURNS>
GstProps *props, GstProps *tomerge
</FUNCTION>
<FUNCTION>
<NAME>gst_props_check_compatibility</NAME>
<RETURNS>gboolean  </RETURNS>
GstProps *fromprops, GstProps *toprops
</FUNCTION>
<FUNCTION>
<NAME>gst_props_save_thyself</NAME>
<RETURNS>xmlNodePtr  </RETURNS>
GstProps *props, xmlNodePtr parent
</FUNCTION>
<FUNCTION>
<NAME>gst_props_load_thyself</NAME>
<RETURNS>GstProps *</RETURNS>
xmlNodePtr parent
</FUNCTION>
<STRUCT>
<NAME>GstPropsEntry</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPropsEntry</NAME>
struct GstPropsEntry {
  GQuark    propid;
  GstPropsId propstype;		

  union {
    /* flat values */
    gboolean bool_data;
    guint32  fourcc_data;
    gint     int_data;

    /* structured values */
    struct {
      GList *entries;
    } list_data;
    struct {
      gint min;
      gint max;
    } int_range_data;
  } data;
};
</STRUCT>
<MACRO>
<NAME>GST_TYPE_AUTOPLUG</NAME>
#define GST_TYPE_AUTOPLUG \
  (gst_object_get_type())
</MACRO>
<MACRO>
<NAME>GST_AUTOPLUG</NAME>
#define GST_AUTOPLUG(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_AUTOPLUG,GstAutoplug))
</MACRO>
<MACRO>
<NAME>GST_AUTOPLUG_CLASS</NAME>
#define GST_AUTOPLUG_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUTOPLUG,GstAutoplugClass))
</MACRO>
<MACRO>
<NAME>GST_IS_AUTOPLUG</NAME>
#define GST_IS_AUTOPLUG(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_AUTOPLUG))
</MACRO>
<MACRO>
<NAME>GST_IS_AUTOPLUG_CLASS</NAME>
#define GST_IS_AUTOPLUG_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUTOPLUG))
</MACRO>
<STRUCT>
<NAME>GstAutoplug</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAutoplugClass</NAME>
</STRUCT>
<MACRO>
<NAME>GST_AUTOPLUG_MAX_COST</NAME>
#define GST_AUTOPLUG_MAX_COST 999999
</MACRO>
<USER_FUNCTION>
<NAME>GstAutoplugCostFunction</NAME>
<RETURNS>guint </RETURNS>
gpointer src, gpointer dest, gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstAutoplugListFunction</NAME>
<RETURNS>GList *</RETURNS>
gpointer data
</USER_FUNCTION>
<STRUCT>
<NAME>GstAutoplug</NAME>
struct GstAutoplug {
  GtkObject object;
};
</STRUCT>
<FUNCTION>
<NAME>gst_autoplug_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_autoplug_caps</NAME>
<RETURNS>GList *</RETURNS>
GstCaps *srccaps, GstCaps *sinkcaps
</FUNCTION>
<FUNCTION>
<NAME>gst_bin_schedule_func</NAME>
<RETURNS>void  </RETURNS>
GstBin *bin
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_ASYNCDISKSRC</NAME>
#define GST_TYPE_ASYNCDISKSRC \
  (gst_asyncdisksrc_get_type())
</MACRO>
<MACRO>
<NAME>GST_ASYNCDISKSRC</NAME>
#define GST_ASYNCDISKSRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrc))
</MACRO>
<MACRO>
<NAME>GST_ASYNCDISKSRC_CLASS</NAME>
#define GST_ASYNCDISKSRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_ASYNCDISKSRC</NAME>
#define GST_IS_ASYNCDISKSRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_ASYNCDISKSRC))
</MACRO>
<MACRO>
<NAME>GST_IS_ASYNCDISKSRC_CLASS</NAME>
#define GST_IS_ASYNCDISKSRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ASYNCDISKSRC))
</MACRO>
<ENUM>
<NAME>GstAsyncDiskSrcFlags</NAME>
typedef enum {
  GST_ASYNCDISKSRC_OPEN		= GST_SRC_FLAG_LAST,

  GST_ASYNCDISKSRC_FLAG_LAST	= GST_SRC_FLAG_LAST + 2,
} GstAsyncDiskSrcFlags;
</ENUM>
<STRUCT>
<NAME>GstAsyncDiskSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAsyncDiskSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAsyncDiskSrc</NAME>
struct GstAsyncDiskSrc {
  GstSrc src;
  /* pads */
  GstPad *srcpad;

  /* filename */
  gchar *filename;
  /* fd */
  gint fd;

  /* mapping parameters */
  gulong size;				/* how long is the file? */
  guchar *map;				/* where the file is mapped to */

  /* details for fallback synchronous read */
  gulong curoffset;			/* current offset in file */
  gulong bytes_per_read;		/* bytes per read */
  gboolean new_seek;

  gulong seq;				/* buffer sequence number */
};
</STRUCT>
<FUNCTION>
<NAME>gst_asyncdisksrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_AUDIOSINK</NAME>
#define GST_TYPE_AUDIOSINK \
  (gst_audiosink_get_type())
</MACRO>
<MACRO>
<NAME>GST_AUDIOSINK</NAME>
#define GST_AUDIOSINK(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_AUDIOSINK,GstAudioSink))
</MACRO>
<MACRO>
<NAME>GST_AUDIOSINK_CLASS</NAME>
#define GST_AUDIOSINK_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIOSINK,GstAudioSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_AUDIOSINK</NAME>
#define GST_IS_AUDIOSINK(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_AUDIOSINK))
</MACRO>
<MACRO>
<NAME>GST_IS_AUDIOSINK_CLASS</NAME>
#define GST_IS_AUDIOSINK_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIOSINK))
</MACRO>
<ENUM>
<NAME>GstAudioSinkFlags</NAME>
typedef enum {
  GST_AUDIOSINK_OPEN		= GST_SINK_FLAG_LAST,

  GST_AUDIOSINK_FLAG_LAST	= GST_SINK_FLAG_LAST+2,
} GstAudioSinkFlags;
</ENUM>
<STRUCT>
<NAME>GstAudioSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAudioSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAudioSink</NAME>
struct GstAudioSink {
  GstSink sink;

  GstPad *sinkpad;

  //GstClockTime clocktime;
  GstClock *clock;
  /* soundcard state */
  int fd;
  int caps; /* the capabilities */
  gint format;
  gint channels;
  gint frequency;
  gboolean mute;
};
</STRUCT>
<FUNCTION>
<NAME>gst_audiosink_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_audiosink_factory_init</NAME>
<RETURNS>gboolean  </RETURNS>
GstElementFactory *factory
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_AUDIOSRC</NAME>
#define GST_TYPE_AUDIOSRC \
  (gst_audiosrc_get_type())
</MACRO>
<MACRO>
<NAME>GST_AUDIOSRC</NAME>
#define GST_AUDIOSRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_AUDIOSRC,GstAudioSrc))
</MACRO>
<MACRO>
<NAME>GST_AUDIOSRC_CLASS</NAME>
#define GST_AUDIOSRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIOSRC,GstAudioSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_AUDIOSRC</NAME>
#define GST_IS_AUDIOSRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_AUDIOSRC))
</MACRO>
<MACRO>
<NAME>GST_IS_AUDIOSRC_CLASS</NAME>
#define GST_IS_AUDIOSRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIOSRC))
</MACRO>
<ENUM>
<NAME>GstAudioSrcFlags</NAME>
typedef enum {
  GST_AUDIOSRC_OPEN		= GST_SRC_FLAG_LAST,

  GST_AUDIOSRC_FLAG_LAST	= GST_SRC_FLAG_LAST+2,
} GstAudioSrcFlags;
</ENUM>
<STRUCT>
<NAME>GstAudioSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAudioSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAudioSrc</NAME>
struct GstAudioSrc {
  GstSrc src;

  /* pads */
  GstPad *srcpad;

  /* sound card */
  gint fd;

  /* audio parameters */
  gint format;
  gint channels;
  gint frequency;

  /* blocking */
  gulong curoffset;
  gulong bytes_per_read;

  gulong seq;

  MetaAudioRaw *meta;
};
</STRUCT>
<FUNCTION>
<NAME>gst_audiosrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<VARIABLE>
<NAME>gst_disksrc_details</NAME>
extern GstElementDetails gst_disksrc_details;
</VARIABLE>
<MACRO>
<NAME>GST_TYPE_DISKSRC</NAME>
#define GST_TYPE_DISKSRC \
  (gst_disksrc_get_type())
</MACRO>
<MACRO>
<NAME>GST_DISKSRC</NAME>
#define GST_DISKSRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_DISKSRC,GstDiskSrc))
</MACRO>
<MACRO>
<NAME>GST_DISKSRC_CLASS</NAME>
#define GST_DISKSRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_DISKSRC,GstDiskSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_DISKSRC</NAME>
#define GST_IS_DISKSRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_DISKSRC))
</MACRO>
<MACRO>
<NAME>GST_IS_DISKSRC_CLASS</NAME>
#define GST_IS_DISKSRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_DISKSRC))
</MACRO>
<ENUM>
<NAME>GstDiskSrcFlags</NAME>
typedef enum {
  GST_DISKSRC_OPEN		= GST_SRC_FLAG_LAST,

  GST_DISKSRC_FLAG_LAST		= GST_SRC_FLAG_LAST+2,
} GstDiskSrcFlags;
</ENUM>
<STRUCT>
<NAME>GstDiskSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstDiskSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstDiskSrc</NAME>
struct GstDiskSrc {
  GstSrc src;
  /* pads */
  GstPad *srcpad;

  /* file state */
  gchar *filename;
  gint fd;

  gulong curoffset;			/* current offset in file */
  gulong bytes_per_read;		/* bytes per read */
  gboolean new_seek;

  gulong seq;				/* buffer sequence number */
  gulong size;				
};
</STRUCT>
<FUNCTION>
<NAME>gst_disksrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_ESDSINK</NAME>
#define GST_TYPE_ESDSINK \
  (gst_esdsink_get_type())
</MACRO>
<MACRO>
<NAME>GST_ESDSINK</NAME>
#define GST_ESDSINK(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_ESDSINK,GstEsdSink))
</MACRO>
<MACRO>
<NAME>GST_ESDSINK_CLASS</NAME>
#define GST_ESDSINK_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ESDSINK,GstEsdSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_ESDSINK</NAME>
#define GST_IS_ESDSINK(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_ESDSINK))
</MACRO>
<MACRO>
<NAME>GST_IS_ESDSINK_CLASS</NAME>
#define GST_IS_ESDSINK_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ESDSINK))
</MACRO>
<STRUCT>
<NAME>GstEsdSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstEsdSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstEsdSink</NAME>
struct GstEsdSink {
  GstFilter filter;

  GstPad *sinkpad;

  /* soundcard state */
  
  int fd;
  gint format;
  gint channels;
  gint frequency;
};
</STRUCT>
<FUNCTION>
<NAME>gst_esdsink_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FAKESINK</NAME>
#define GST_TYPE_FAKESINK \
  (gst_fakesink_get_type())
</MACRO>
<MACRO>
<NAME>GST_FAKESINK</NAME>
#define GST_FAKESINK(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_FAKESINK,GstFakeSink))
</MACRO>
<MACRO>
<NAME>GST_FAKESINK_CLASS</NAME>
#define GST_FAKESINK_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FAKESINK,GstFakeSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKESINK</NAME>
#define GST_IS_FAKESINK(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_FAKESINK))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKESINK_CLASS</NAME>
#define GST_IS_FAKESINK_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKESINK))
</MACRO>
<STRUCT>
<NAME>GstFakeSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSink</NAME>
struct GstFakeSink {
  GstSink sink;

  GstPad *sinkpad;
};
</STRUCT>
<FUNCTION>
<NAME>gst_fakesink_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GstFakeSrcOutputType</NAME>
typedef enum {
  FAKESRC_FIRST_LAST_LOOP = 1,
  FAKESRC_LAST_FIRST_LOOP,
  FAKESRC_PING_PONG,
  FAKESRC_ORDERED_RANDOM,
  FAKESRC_RANDOM,
  FAKESRC_PATERN_LOOP,
  FAKESRC_PING_PONG_PATERN,
  FAKESRC_GET_ALWAYS_SUCEEDS,
} GstFakeSrcOutputType;
</ENUM>
<MACRO>
<NAME>GST_TYPE_FAKESRC</NAME>
#define GST_TYPE_FAKESRC \
  (gst_fakesrc_get_type())
</MACRO>
<MACRO>
<NAME>GST_FAKESRC</NAME>
#define GST_FAKESRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_FAKESRC,GstFakeSrc))
</MACRO>
<MACRO>
<NAME>GST_FAKESRC_CLASS</NAME>
#define GST_FAKESRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FAKESRC,GstFakeSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKESRC</NAME>
#define GST_IS_FAKESRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_FAKESRC))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKESRC_CLASS</NAME>
#define GST_IS_FAKESRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKESRC))
</MACRO>
<STRUCT>
<NAME>GstFakeSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSrc</NAME>
struct GstFakeSrc {
  GstSrc src;

  gboolean loop_based;
  gint numsrcpads;
  GSList *srcpads;
  GstFakeSrcOutputType output;
  gchar *patern;
  GList *paternlist;
};
</STRUCT>
<FUNCTION>
<NAME>gst_fakesrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FDSINK</NAME>
#define GST_TYPE_FDSINK \
  (gst_fdsink_get_type())
</MACRO>
<MACRO>
<NAME>GST_FDSINK</NAME>
#define GST_FDSINK(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_FDSINK,GstFdSink))
</MACRO>
<MACRO>
<NAME>GST_FDSINK_CLASS</NAME>
#define GST_FDSINK_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FDSINK,GstFdSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FDSINK</NAME>
#define GST_IS_FDSINK(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_FDSINK))
</MACRO>
<MACRO>
<NAME>GST_IS_FDSINK_CLASS</NAME>
#define GST_IS_FDSINK_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FDSINK))
</MACRO>
<STRUCT>
<NAME>GstFdSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSink</NAME>
struct GstFdSink {
  GstSink sink;

  GstPad *sinkpad;

  int fd;
};
</STRUCT>
<FUNCTION>
<NAME>gst_fdsink_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FDSRC</NAME>
#define GST_TYPE_FDSRC \
  (gst_fdsrc_get_type())
</MACRO>
<MACRO>
<NAME>GST_FDSRC</NAME>
#define GST_FDSRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_FDSRC,GstFdSrc))
</MACRO>
<MACRO>
<NAME>GST_FDSRC_CLASS</NAME>
#define GST_FDSRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FDSRC,GstFdSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FDSRC</NAME>
#define GST_IS_FDSRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_FDSRC))
</MACRO>
<MACRO>
<NAME>GST_IS_FDSRC_CLASS</NAME>
#define GST_IS_FDSRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FDSRC))
</MACRO>
<STRUCT>
<NAME>GstFdSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSrc</NAME>
struct GstFdSrc {
  GstSrc src;
  /* pads */
  GstPad *srcpad;

  /* fd */
  gint fd;

  gulong curoffset;			/* current offset in file */
  gulong bytes_per_read;		/* bytes per read */

  gulong seq;				/* buffer sequence number */
};
</STRUCT>
<FUNCTION>
<NAME>gst_fdsrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_HTTPSRC</NAME>
#define GST_TYPE_HTTPSRC \
  (gst_httpsrc_get_type())
</MACRO>
<MACRO>
<NAME>GST_HTTPSRC</NAME>
#define GST_HTTPSRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_HTTPSRC,GstHttpSrc))
</MACRO>
<MACRO>
<NAME>GST_HTTPSRC_CLASS</NAME>
#define GST_HTTPSRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_HTTPSRC,GstHttpSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_HTTPSRC</NAME>
#define GST_IS_HTTPSRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_HTTPSRC))
</MACRO>
<MACRO>
<NAME>GST_IS_HTTPSRC_CLASS</NAME>
#define GST_IS_HTTPSRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_HTTPSRC))
</MACRO>
<ENUM>
<NAME>GstHttpSrcFlags</NAME>
typedef enum {
  GST_HTTPSRC_OPEN		= GST_SRC_FLAG_LAST,

  GST_HTTPSRC_FLAG_LAST		= GST_SRC_FLAG_LAST+2,
} GstHttpSrcFlags;
</ENUM>
<STRUCT>
<NAME>GstHttpSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstHttpSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstHttpSrc</NAME>
struct GstHttpSrc {
  GstSrc src;
  /* pads */
  GstPad *srcpad;

  gchar *url;
  ghttp_request *request;
  int fd;

  gulong curoffset;			/* current offset in file */
  gulong bytes_per_read;		/* bytes per read */
};
</STRUCT>
<FUNCTION>
<NAME>gst_httpsrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_IDENTITY</NAME>
#define GST_TYPE_IDENTITY \
  (gst_identity_get_type())
</MACRO>
<MACRO>
<NAME>GST_IDENTITY</NAME>
#define GST_IDENTITY(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_IDENTITY,GstIdentity))
</MACRO>
<MACRO>
<NAME>GST_IDENTITY_CLASS</NAME>
#define GST_IDENTITY_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_IDENTITY,GstIdentityClass))
</MACRO>
<MACRO>
<NAME>GST_IS_IDENTITY</NAME>
#define GST_IS_IDENTITY(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_IDENTITY))
</MACRO>
<MACRO>
<NAME>GST_IS_IDENTITY_CLASS</NAME>
#define GST_IS_IDENTITY_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_IDENTITY))
</MACRO>
<STRUCT>
<NAME>GstIdentity</NAME>
</STRUCT>
<STRUCT>
<NAME>GstIdentityClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstIdentity</NAME>
struct GstIdentity {
  GstFilter filter;

  GstPad *sinkpad;
  GstPad *srcpad;

  gboolean loop_based;
};
</STRUCT>
<FUNCTION>
<NAME>gst_identity_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_QUEUE</NAME>
#define GST_TYPE_QUEUE \
  (gst_queue_get_type())
</MACRO>
<MACRO>
<NAME>GST_QUEUE</NAME>
#define GST_QUEUE(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_QUEUE,GstQueue))
</MACRO>
<MACRO>
<NAME>GST_QUEUE_CLASS</NAME>
#define GST_QUEUE_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_QUEUE,GstQueueClass))
</MACRO>
<MACRO>
<NAME>GST_IS_QUEUE</NAME>
#define GST_IS_QUEUE(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_QUEUE))
</MACRO>
<MACRO>
<NAME>GST_IS_QUEUE_CLASS</NAME>
#define GST_IS_QUEUE_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_QUEUE))
</MACRO>
<STRUCT>
<NAME>GstQueue</NAME>
</STRUCT>
<STRUCT>
<NAME>GstQueueClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstQueue</NAME>
struct GstQueue {
  GstConnection Connection;

  GstPad *sinkpad;
  GstPad *srcpad;

  /* the queue of buffers we're keeping our grubby hands on */
  GSList *queue;

  gint level_buffers;	/* number of buffers queued here */
  gint max_buffers;	/* maximum number of buffers queued here */
  gboolean block;	/* if set to FALSE, _get returns NULL if queue empty */
  gint level_bytes;	/* number of bytes queued here */
  gint size_buffers;	/* size of queue in buffers */
  gint size_bytes;	/* size of queue in bytes */

  GMutex *emptylock;	/* used when the queue is empty */
  GCond *emptycond;
  GMutex *fulllock;	/* used when the queue is full */
  GCond *fullcond;
};
</STRUCT>
<FUNCTION>
<NAME>gst_queue_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_SINESRC</NAME>
#define GST_TYPE_SINESRC \
  (gst_sinesrc_get_type())
</MACRO>
<MACRO>
<NAME>GST_SINESRC</NAME>
#define GST_SINESRC(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_SINESRC,GstSineSrc))
</MACRO>
<MACRO>
<NAME>GST_SINESRC_CLASS</NAME>
#define GST_SINESRC_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SINESRC,GstSineSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_SINESRC</NAME>
#define GST_IS_SINESRC(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_SINESRC))
</MACRO>
<MACRO>
<NAME>GST_IS_SINESRC_CLASS</NAME>
#define GST_IS_SINESRC_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SINESRC))
</MACRO>
<STRUCT>
<NAME>GstSineSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstSineSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstSineSrc</NAME>
struct GstSineSrc {
  GstSrc src;

  /* pads */
  GstPad *srcpad;

  /* parameters */
  gdouble volume;
  gint freq;

  /* audio parameters */
  gint format;
  gint channels;
  gint frequency;

  gulong seq;

  MetaAudioRaw meta;
  gboolean sentmeta;
};
</STRUCT>
<FUNCTION>
<NAME>gst_sinesrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_TYPEFIND</NAME>
#define GST_TYPE_TYPEFIND \
  (gst_typefind_get_type())
</MACRO>
<MACRO>
<NAME>GST_TYPEFIND</NAME>
#define GST_TYPEFIND(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_TYPEFIND,GstTypeFind))
</MACRO>
<MACRO>
<NAME>GST_TYPEFIND_CLASS</NAME>
#define GST_TYPEFIND_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_TYPEFIND,GstTypeFindClass))
</MACRO>
<MACRO>
<NAME>GST_IS_TYPEFIND</NAME>
#define GST_IS_TYPEFIND(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_TYPEFIND))
</MACRO>
<MACRO>
<NAME>GST_IS_TYPEFIND_CLASS</NAME>
#define GST_IS_TYPEFIND_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_TYPEFIND))
</MACRO>
<STRUCT>
<NAME>GstTypeFind</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTypeFindClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTypeFind</NAME>
struct GstTypeFind {
  GstSink sink;

  GstPad *sinkpad;

  GstCaps *caps;
};
</STRUCT>
<FUNCTION>
<NAME>gst_typefind_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_PIPEFILTER</NAME>
#define GST_TYPE_PIPEFILTER \
  (gst_pipefilter_get_type())
</MACRO>
<MACRO>
<NAME>GST_PIPEFILTER</NAME>
#define GST_PIPEFILTER(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_PIPEFILTER,GstPipefilter))
</MACRO>
<MACRO>
<NAME>GST_PIPEFILTER_CLASS</NAME>
#define GST_PIPEFILTER_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_PIPEFILTER,GstPipefilterClass))
</MACRO>
<MACRO>
<NAME>GST_IS_PIPEFILTER</NAME>
#define GST_IS_PIPEFILTER(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_PIPEFILTER))
</MACRO>
<MACRO>
<NAME>GST_IS_PIPEFILTER_CLASS</NAME>
#define GST_IS_PIPEFILTER_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_PIPEFILTER))
</MACRO>
<ENUM>
<NAME>GstPipeFilterFlags</NAME>
typedef enum {
  GST_PIPEFILTER_OPEN		= GST_FILTER_FLAG_LAST,

  GST_PIPEFILTER_FLAG_LAST	= GST_FILTER_FLAG_LAST,
} GstPipeFilterFlags;
</ENUM>
<STRUCT>
<NAME>GstPipefilter</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPipefilterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPipefilter</NAME>
struct GstPipefilter {
  GstFilter filter;

  GstPad *sinkpad;
  GstPad *srcpad;

  /* command */
  gchar **command;
  gchar *orig_command;
  /* fd */
  gint fdout[2];
  gint fdin[2];
  pid_t   childpid;

  gulong curoffset;                     /* current offset in file */
  gulong bytes_per_read;                /* bytes per read */

  gulong seq;                           /* buffer sequence number */
};
</STRUCT>
<FUNCTION>
<NAME>gst_pipefilter_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>MetaAudioRaw</NAME>
</STRUCT>
<STRUCT>
<NAME>MetaAudioRaw</NAME>
struct MetaAudioRaw {
  GstMeta meta;

  /* formatting information */
  gint format;
  gint channels;
  gint frequency;
  gint bps;
};
</STRUCT>
<STRUCT>
<NAME>MetaAudioSpectrum</NAME>
</STRUCT>
<STRUCT>
<NAME>MetaAudioSpectrum</NAME>
struct MetaAudioSpectrum {
  GstMeta meta;

  /* data representation */
  gint16 bands;			/* how many bands are represented */
  gint8 channels;		/* how many audio channels are there? */
  gboolean interleaved;		/* are the channels interleaved? */

  /* spectrum details */
  gint16 lowfreq;
  gint16 highfreq;
  gint16 steps;
};
</STRUCT>
<STRUCT>
<NAME>MetaVideoRaw</NAME>
</STRUCT>
<STRUCT>
<NAME>MetaDGA</NAME>
</STRUCT>
<STRUCT>
<NAME>MetaOverlay</NAME>
</STRUCT>
<STRUCT>
<NAME>OverlayClip</NAME>
</STRUCT>
<STRUCT>
<NAME>OverlayClip</NAME>
struct OverlayClip {
  int x1, x2, y1, y2;
};
</STRUCT>
<STRUCT>
<NAME>MetaDGA</NAME>
struct MetaDGA {
  /* the base address of the screen */
  void *base;
  /* the dimensions of the screen */
  int swidth, sheight;
  /* the number of bytes in a line */
  int bytes_per_line;
};
</STRUCT>
<STRUCT>
<NAME>MetaOverlay</NAME>
struct MetaOverlay {
  /* the position of the window */
  int wx, wy;
  /* a reference to the object sending overlay change events */
  GtkWidget *overlay_element;
  /* the number of overlay regions */
  int clip_count;
  /* the overlay regions of the display window */
  struct _OverlayClip overlay_clip[32];

  gint width;
  gint height;
	
  gboolean did_overlay;
  gboolean fully_obscured;
};
</STRUCT>
<STRUCT>
<NAME>MetaVideoRaw</NAME>
struct MetaVideoRaw {
  GstMeta meta;

  /* formatting information */
  GstColorSpaceType format;
  GdkVisual *visual;
  /* dimensions of the video buffer */
  gint width;
  gint height;
  /* a pointer to the overlay info if the sink supports this */
  MetaOverlay *overlay_info;
  /* a pointer to the DGA info if the sink supports this */
  MetaDGA *dga_info;
};
</STRUCT>