<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,GstObject))
</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>
<STRUCT>
<NAME>GstObject</NAME>
struct GstObject {
  GtkObject object;
  gchar *name;

  GstObject *parent;
};
</STRUCT>
<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>
<FUNCTION>
<NAME>gst_object_ref</NAME>
<RETURNS>void  </RETURNS>
GstObject *object
</FUNCTION>
<FUNCTION>
<NAME>gst_object_unref</NAME>
<RETURNS>void  </RETURNS>
GstObject *object
</FUNCTION>
<FUNCTION>
<NAME>gst_object_destroy</NAME>
<RETURNS>void  </RETURNS>
GstObject *object
</FUNCTION>
<FUNCTION>
<NAME>gst_object_set_name</NAME>
<RETURNS>void  </RETURNS>
GstObject *object,gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_object_get_name</NAME>
<RETURNS>gchar  *</RETURNS>
GstObject *object
</FUNCTION>
<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,GstBin))
</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>
<STRUCT>
<NAME>GstBin</NAME>
</STRUCT>
<STRUCT>
<NAME>GstBinClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstBin</NAME>
struct GstBin {
  GstElement element;

  gint numchildren;
  GList *children;

  GstObject *parent;
};
</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>
<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_init</NAME>
<RETURNS>void  </RETURNS>
int *argc,char **argv[]
</FUNCTION>
<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,GstPad))
</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>
<STRUCT>
<NAME>GstPad</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPadClass</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GstPadChainFunction</NAME>
<RETURNS>void </RETURNS>
GstPad *pad,GstBuffer *buf
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GstPadPushFunction</NAME>
<RETURNS>void </RETURNS>
GstPad *pad
</USER_FUNCTION>
<ENUM>
<NAME>GstPadDirection</NAME>
typedef enum {
  GST_PAD_UNKNOWN,
  GST_PAD_SRC,
  GST_PAD_SINK,
} GstPadDirection;
</ENUM>
<STRUCT>
<NAME>GstPad</NAME>
struct GstPad {
  GstObject object;

  gchar *name;

  guint32 type;
  guint16 flags;
  GstPadDirection direction;

  GstPad *peer;

  GstPadChainFunction chain;

  GstObject *parent;
  GstObject *ghostparent;
};
</STRUCT>
<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>
<FUNCTION>
<NAME>gst_pad_destroy</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad
</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_get_type_id</NAME>
<RETURNS>guint32  </RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_type_id</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,guint16 id
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_name</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_get_name</NAME>
<RETURNS>gchar  *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_parent</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,GstObject *parent
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_set_ghost_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_get_ghost_parent</NAME>
<RETURNS>GstObject  *</RETURNS>
GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_pad_connect</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_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,GstPipeline))
</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;
};
</STRUCT>
<FUNCTION>
<NAME>gst_pipeline_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_pipeline_new</NAME>
<RETURNS>GstPipeline  *</RETURNS>
guchar *name
</FUNCTION>
<ENUM>
<NAME>GstBufferFlags</NAME>
typedef enum {
  GST_BUFFER_FREEABLE		= 1 << 0,
} GstBufferFlags;
</ENUM>
<MACRO>
<NAME>GST_TYPE_BUFFER</NAME>
#define GST_TYPE_BUFFER \
  (gst_buffer_get_type())
</MACRO>
<MACRO>
<NAME>GST_BUFFER</NAME>
#define GST_BUFFER(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_BUFFER,GstBuffer))
</MACRO>
<MACRO>
<NAME>GST_BUFFER_CLASS</NAME>
#define GST_BUFFER_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_BUFFER,GstBuffer))
</MACRO>
<MACRO>
<NAME>GST_IS_BUFFER</NAME>
#define GST_IS_BUFFER(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_BUFFER))
</MACRO>
<MACRO>
<NAME>GST_IS_BUFFER_CLASS</NAME>
#define GST_IS_BUFFER_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_BUFFER)))
</MACRO>
<STRUCT>
<NAME>GstBuffer</NAME>
</STRUCT>
<STRUCT>
<NAME>GstBufferClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstBuffer</NAME>
struct GstBuffer {
  GstObject object;

  gint refcount;

  gint32 type;
  gint32 flags;

  gpointer data;
  gulong datasize;
  gulong srcoffset;			/* offset in source if known */

  gpointer meta;
};
</STRUCT>
<MACRO>
<NAME>GST_BUFFER_FLAGS</NAME>
#define GST_BUFFER_FLAGS(buf) (GST_BUFFER(buf)->flags)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_SET_FLAGS</NAME>
#define GST_BUFFER_SET_FLAGS(buf,flag) G_STMT_START{ (GST_BUFFER_FLAGS (buf) |= (flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_BUFFER_UNSET_FLAGS</NAME>
#define GST_BUFFER_UNSET_FLAGS(buf,flag) G_STMT_START{ (GST_BUFFER_FLAGS (buf) &= ~(flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_BUFFER_IS_SET</NAME>
#define GST_BUFFER_IS_SET(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_DATASIZE</NAME>
#define GST_BUFFER_DATASIZE(buf)	(GST_BUFFER(buf)->datasize)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_SRCOFFSET</NAME>
#define GST_BUFFER_SRCOFFSET(buf)	(GST_BUFFER(buf)->srcoffset)
</MACRO>
<MACRO>
<NAME>GST_BUFFER_META</NAME>
#define GST_BUFFER_META(buf)		(GST_BUFFER(buf)->meta)
</MACRO>
<FUNCTION>
<NAME>gst_buffer_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_new</NAME>
<RETURNS>GstBuffer  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_destroy</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer
</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,gint count
</FUNCTION>
<FUNCTION>
<NAME>gst_buffer_unref</NAME>
<RETURNS>void  </RETURNS>
GstBuffer *buffer
</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,GstSrc))
</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		= 1 << 0,
} GstSrcFlags;
</ENUM>
<MACRO>
<NAME>GST_SRC_FLAGS</NAME>
#define GST_SRC_FLAGS(obj)	(GST_SRC(obj)->flags)
</MACRO>
<MACRO>
<NAME>GST_SRC_ASYNC</NAME>
#define GST_SRC_ASYNC(obj)	((GST_SRC_FLAGS(obj) & GST_SRC_ASYNC)
</MACRO>
<STRUCT>
<NAME>GstSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstSrc</NAME>
struct GstSrc {
  GstElement element;
  gint32 flags;
};
</STRUCT>
<MACRO>
<NAME>GST_SRC_SET_FLAGS</NAME>
#define GST_SRC_SET_FLAGS(src,flag)   G_STMT_START{ (GST_SRC_FLAGS (src) |= (flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_SRC_UNSET_FLAGS</NAME>
#define GST_SRC_UNSET_FLAGS(src,flag)  G_STMT_START{ (GST_SRC_FLAGS (src) &= ~(flag)); }G_STMT_END
</MACRO>
<FUNCTION>
<NAME>gst_src_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_src_signal_eof</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src
</FUNCTION>
<FUNCTION>
<NAME>gst_src_push</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src
</FUNCTION>
<FUNCTION>
<NAME>gst_src_push_region</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src,gulong offset,gulong size
</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,GstFilter))
</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>
<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>
<USER_FUNCTION>
<NAME>GstTypeFindFunc</NAME>
<RETURNS>gint </RETURNS>
GstBuffer *buf,gpointer *private
</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 */

  GstTypeFindFunc typefindfunc;	/* typefind function */

  GList *srcs;			/* list of src objects for this type */
  GList *sinks;			/* list of sink objects for type */
};
</STRUCT>
<STRUCT>
<NAME>GstTypeFactory</NAME>
struct GstTypeFactory {
  gchar *mime;
  gchar *exts;
  GstTypeFindFunc typefindfunc;
};
</STRUCT>
<FUNCTION>
<NAME>gst_type_initialize</NAME>
<RETURNS>void  </RETURNS>

</FUNCTION>
<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_add_src</NAME>
<RETURNS>void  </RETURNS>
guint16 id,GstElementFactory *src
</FUNCTION>
<FUNCTION>
<NAME>gst_type_add_sink</NAME>
<RETURNS>void  </RETURNS>
guint16 id,GstElementFactory *sink
</FUNCTION>
<FUNCTION>
<NAME>gst_type_get_srcs</NAME>
<RETURNS>GList  *</RETURNS>
guint16 id
</FUNCTION>
<FUNCTION>
<NAME>gst_type_get_sinks</NAME>
<RETURNS>GList  *</RETURNS>
guint16 id
</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>

</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,GstSink))
</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>
<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_ELEMENTFACTORY</NAME>
#define GST_TYPE_ELEMENTFACTORY \
  (gst_elementfactory_get_type())
</MACRO>
<MACRO>
<NAME>GST_ELEMENTFACTORY</NAME>
#define GST_ELEMENTFACTORY(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_ELEMENTFACTORY,GstElementFactory))
</MACRO>
<MACRO>
<NAME>GST_ELEMENTFACTORY_CLASS</NAME>
#define GST_ELEMENTFACTORY_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ELEMENTFACTORY,GstElementFactory))
</MACRO>
<MACRO>
<NAME>GST_IS_ELEMENTFACTORY</NAME>
#define GST_IS_ELEMENTFACTORY(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_ELEMENTFACTORY))
</MACRO>
<MACRO>
<NAME>GST_IS_ELEMENTFACTORY_CLASS</NAME>
#define GST_IS_ELEMENTFACTORY_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ELEMENTFACTORY)))
</MACRO>
<USER_FUNCTION>
<NAME>GstElementFactoryNewFunc</NAME>
<RETURNS>GstElement *</RETURNS>
gchar *name
</USER_FUNCTION>
<STRUCT>
<NAME>GstElementFactory</NAME>
</STRUCT>
<STRUCT>
<NAME>GstElementFactoryClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstElementFactory</NAME>
struct GstElementFactory {
  GstObject object;

  GtkType type;

  GstElementFactoryNewFunc newfunc;
};
</STRUCT>
<FUNCTION>
<NAME>gst_elementfactory_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_new</NAME>
<RETURNS>GstElementFactory *</RETURNS>
gchar *name,GtkType type,GstElementFactoryNewFunc newf
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_register</NAME>
<RETURNS>void  </RETURNS>
GstElementFactory *elementfactory
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_find</NAME>
<RETURNS>GstElementFactory  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_get_list</NAME>
<RETURNS>GList  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gst_elementfactory_create</NAME>
<RETURNS>GstElement  *</RETURNS>
GstElementFactory *factory,gchar *name
</FUNCTION>
<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,GstElement))
</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(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ELEMENT)))
</MACRO>
<STRUCT>
<NAME>GstElement</NAME>
</STRUCT>
<STRUCT>
<NAME>GstElementClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstElement</NAME>
struct GstElement {
  GstObject object;

  gint numpads;
  GList *pads;
};
</STRUCT>
<FUNCTION>
<NAME>gst_element_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_element_new</NAME>
<RETURNS>GstElement  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_element_add_pad</NAME>
<RETURNS>void  </RETURNS>
GstElement *element,GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>gst_element_add_ghost_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_connect</NAME>
<RETURNS>void  </RETURNS>
GstElement *src,gchar *srcpadname,GstElement *dest,gchar *destpadname
</FUNCTION>
<STRUCT>
<NAME>GstPlugin</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPluginElement</NAME>
</STRUCT>
<STRUCT>
<NAME>GstPlugin</NAME>
struct GstPlugin {
  gchar *name;			/* name of the plugin */

  GList *types;			/* list of types provided */
  GList *elements;		/* list of elements provided */
  GList *identifiers;		/* list of identifiers */
};
</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_init</NAME>
<RETURNS>void  </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_load_all</NAME>
<RETURNS>void  </RETURNS>

</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_plugin_add_factory</NAME>
<RETURNS>void  </RETURNS>
GstPlugin *plugin,GstElementFactory *factory
</FUNCTION>
<FUNCTION>
<NAME>gst_plugin_find_elementfactory</NAME>
<RETURNS>GstElementFactory  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_int_arg</NAME>
<RETURNS>gint  </RETURNS>
GstObject *object,guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_long_arg</NAME>
<RETURNS>glong  </RETURNS>
GstObject *object,guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_float_arg</NAME>
<RETURNS>gfloat  </RETURNS>
GstObject *object,guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_string_arg</NAME>
<RETURNS>guchar  *</RETURNS>
GstObject *object,guchar *argname
</FUNCTION>
<FUNCTION>
<NAME>gst_util_get_pointer_arg</NAME>
<RETURNS>gpointer  </RETURNS>
GstObject *object,guchar *argname
</FUNCTION>
<ENUM>
<NAME>GstMetaFlags</NAME>
typedef enum {
  GST_META_FREEABLE             = 1 << 0,
} GstMetaFlags;
</ENUM>
<MACRO>
<NAME>GST_META</NAME>
#define GST_META(meta) ((GstMeta *)(meta))
</MACRO>
<STRUCT>
<NAME>GstMeta</NAME>
</STRUCT>
<STRUCT>
<NAME>GstMeta</NAME>
struct GstMeta {
  guint16 type;
  guint16 size;
  guint16 flags;
  guint16 refcount;

  GstMeta *(*copy) (GstMeta *meta);
  void (*destroy) (GstMeta *meta);
};
</STRUCT>
<MACRO>
<NAME>GST_META_FLAGS</NAME>
#define GST_META_FLAGS(meta) (GST_META(meta)->flags)
</MACRO>
<MACRO>
<NAME>GST_META_SET_FLAGS</NAME>
#define GST_META_SET_FLAGS(meta,flag) G_STMT_START{ (GST_META_FLAGS(meta) |= (flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_META_UNSET_FLAGS</NAME>
#define GST_META_UNSET_FLAGS(meta,flag) G_STMT_START{ (GST_META_FLAGS(meta) &= ~(flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_META_IS_SET</NAME>
#define GST_META_IS_SET(meta,flag) G_STMT_START{ (GST_META_FLAGS(meta) && (flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GST_META_TYPE</NAME>
#define GST_META_TYPE(meta) (GST_META(meta)->type)
</MACRO>
<MACRO>
<NAME>GST_META_IS_TYPE</NAME>
#define GST_META_IS_TYPE(meta,type) ((GST_META(meta)->type) == (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>
<FUNCTION>
<NAME>gst_meta_cow</NAME>
<RETURNS>GstMeta  *</RETURNS>
GstMeta *meta
</FUNCTION>
<FUNCTION>
<NAME>gst_trace_read_tsc</NAME>
<RETURNS>void  </RETURNS>
guint64 *dst
</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>
<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>
<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,GstAsyncDiskSrc))
</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>
<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 */

  gulong seq;				/* buffer sequence number */
};
</STRUCT>
<FUNCTION>
<NAME>gst_asyncdisksrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_asyncdisksrc_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_asyncdisksrc_new_with_file</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name,gchar *file
</FUNCTION>
<FUNCTION>
<NAME>gst_asyncdisksrc_push</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src
</FUNCTION>
<FUNCTION>
<NAME>gst_asyncdisksrc_push_region</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src,gulong offset,gulong size
</FUNCTION>
<FUNCTION>
<NAME>gst_asyncdisksrc_set_filename</NAME>
<RETURNS>void  </RETURNS>
GstAsyncDiskSrc *asyncdisksrc,gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gst_asyncdisksrc_get_filename</NAME>
<RETURNS>gchar  *</RETURNS>
GstAsyncDiskSrc *asyncdisksrc
</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,GstAudioSink))
</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>
<STRUCT>
<NAME>GstAudioSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAudioSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstAudioSink</NAME>
struct GstAudioSink {
  GstFilter filter;

  GstPad *sinkpad;

  /* soundcard state */
  int fd;
  gint format;
  gint channels;
  gint frequency;
};
</STRUCT>
<FUNCTION>
<NAME>gst_audiosink_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_audiosink_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_audiosink_chain</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,GstBuffer *buf
</FUNCTION>
<FUNCTION>
<NAME>gst_audiosink_sync_parms</NAME>
<RETURNS>void  </RETURNS>
GstAudioSink *audiosink
</FUNCTION>
<FUNCTION>
<NAME>gst_audiosink_set_format</NAME>
<RETURNS>void  </RETURNS>
GstAudioSink *audiosink,gint format
</FUNCTION>
<FUNCTION>
<NAME>gst_audiosink_set_channels</NAME>
<RETURNS>void  </RETURNS>
GstAudioSink *audiosink,gint channels
</FUNCTION>
<FUNCTION>
<NAME>gst_audiosink_set_frequency</NAME>
<RETURNS>void  </RETURNS>
GstAudioSink *audiosink,gint frequency
</FUNCTION>
<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,GstDiskSrc))
</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>
<STRUCT>
<NAME>GstDiskSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstDiskSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstDiskSrc</NAME>
struct GstDiskSrc {
  GstSrc src;
  /* pads */
  GstPad *srcpad;

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

  gulong size;

  gulong curoffset;			/* current offset in file */
  gulong seq;				/* buffer sequence number */
  gulong bytes_per_read;		/* bytes per read */
};
</STRUCT>
<FUNCTION>
<NAME>gst_disksrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_disksrc_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_disksrc_new_with_location</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name,gchar *location
</FUNCTION>
<FUNCTION>
<NAME>gst_disksrc_push</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src
</FUNCTION>
<FUNCTION>
<NAME>gst_disksrc_set_filename</NAME>
<RETURNS>void  </RETURNS>
GstDiskSrc *disksrc,gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gst_disksrc_get_filename</NAME>
<RETURNS>gchar  *</RETURNS>
GstDiskSrc *disksrc
</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,GstEsdSink))
</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>
<FUNCTION>
<NAME>gst_esdsink_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_esdsink_chain</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,GstBuffer *buf
</FUNCTION>
<FUNCTION>
<NAME>gst_esdsink_sync_parms</NAME>
<RETURNS>void  </RETURNS>
GstEsdSink *esdsink
</FUNCTION>
<FUNCTION>
<NAME>gst_esdsink_set_format</NAME>
<RETURNS>void  </RETURNS>
GstEsdSink *esdsink,gint format
</FUNCTION>
<FUNCTION>
<NAME>gst_esdsink_set_channels</NAME>
<RETURNS>void  </RETURNS>
GstEsdSink *esdsink,gint channels
</FUNCTION>
<FUNCTION>
<NAME>gst_esdsink_set_frequency</NAME>
<RETURNS>void  </RETURNS>
GstEsdSink *esdsink,gint frequency
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FAKEFILTER</NAME>
#define GST_TYPE_FAKEFILTER \
  (gst_fakefilter_get_type())
</MACRO>
<MACRO>
<NAME>GST_FAKEFILTER</NAME>
#define GST_FAKEFILTER(obj) \
  (GTK_CHECK_CAST((obj),GST_TYPE_FAKEFILTER,GstFakeFilter))
</MACRO>
<MACRO>
<NAME>GST_FAKEFILTER_CLASS</NAME>
#define GST_FAKEFILTER_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FAKEFILTER,GstFakeFilter))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKEFILTER</NAME>
#define GST_IS_FAKEFILTER(obj) \
  (GTK_CHECK_TYPE((obj),GST_TYPE_FAKEFILTER))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKEFILTER_CLASS</NAME>
#define GST_IS_FAKEFILTER_CLASS(obj) \
  (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKEFILTER)))
</MACRO>
<STRUCT>
<NAME>GstFakeFilter</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeFilterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeFilter</NAME>
struct GstFakeFilter {
  GstFilter filter;

  GstPad *sinkpad;
  GstPad *srcpad;

  gint control;
};
</STRUCT>
<FUNCTION>
<NAME>gst_fakefilter_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_fakefilter_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_fakefilter_chain</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,GstBuffer *buf
</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,GstFakeSink))
</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>
<FUNCTION>
<NAME>gst_fakesink_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_fakesink_chain</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,GstBuffer *buf
</FUNCTION>
<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,GstFakeSrc))
</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;

  GstPad *srcpad;
};
</STRUCT>
<FUNCTION>
<NAME>gst_fakesrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_fakesrc_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_fakesrc_push</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src
</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,GstFdSink))
</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>
<FUNCTION>
<NAME>gst_fdsink_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_fdsink_new_with_fd</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name,gint fd
</FUNCTION>
<FUNCTION>
<NAME>gst_fdsink_chain</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,GstBuffer *buf
</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,GstFdSrc))
</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;

  /* if we can get it... */
  gulong size;

  gulong curoffset;			/* current offset in file */
  gulong seq;				/* buffer sequence number */
  gulong bytes_per_read;		/* bytes per read */
};
</STRUCT>
<FUNCTION>
<NAME>gst_fdsrc_get_type</NAME>
<RETURNS>GtkType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gst_fdsrc_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_fdsrc_new_with_fd</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name,int fd
</FUNCTION>
<FUNCTION>
<NAME>gst_fdsrc_push</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,GstTee))
</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;
  GstPad *src1pad;
  GstPad *src2pad;
};
</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_chain</NAME>
<RETURNS>void  </RETURNS>
GstPad *pad,GstBuffer *buf
</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,GstHttpSrc))
</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>
<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>
<FUNCTION>
<NAME>gst_httpsrc_new</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gst_httpsrc_new_with_url</NAME>
<RETURNS>GstElement  *</RETURNS>
gchar *name,guchar *url
</FUNCTION>
<FUNCTION>
<NAME>gst_httpsrc_push</NAME>
<RETURNS>void  </RETURNS>
GstSrc *src
</FUNCTION>
<FUNCTION>
<NAME>gst_httpsrc_set_url</NAME>
<RETURNS>void  </RETURNS>
GstHttpSrc *httpsrc,gchar *url
</FUNCTION>
<FUNCTION>
<NAME>gst_httpsrc_get_url</NAME>
<RETURNS>gchar  *</RETURNS>
GstHttpSrc *httpsrc
</FUNCTION>
<FUNCTION>
<NAME>gst_httpsrc_set_bytesperread</NAME>
<RETURNS>void  </RETURNS>
GstHttpSrc *httpsrc,gint bytes
</FUNCTION>
<FUNCTION>
<NAME>gst_httpsrc_get_bytesperread</NAME>
<RETURNS>gint  </RETURNS>
GstHttpSrc *httpsrc
</FUNCTION>
<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>MetaAudioRaw</NAME>
</STRUCT>
<STRUCT>
<NAME>MetaAudioRaw</NAME>
struct MetaAudioRaw {
  GstMeta meta;

  /* formatting information */
  gint format;
  gint channels;
  gint frequency;
  gint bps;
};
</STRUCT>
