<MACRO>
<NAME>GST_TYPE_CAPSFILTER</NAME>
#define GST_TYPE_CAPSFILTER \
  (gst_capsfilter_get_type())
</MACRO>
<MACRO>
<NAME>GST_CAPSFILTER</NAME>
#define GST_CAPSFILTER(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CAPSFILTER,GstCapsFilter))
</MACRO>
<MACRO>
<NAME>GST_CAPSFILTER_CLASS</NAME>
#define GST_CAPSFILTER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CAPSFILTER,GstCapsFilterClass))
</MACRO>
<MACRO>
<NAME>GST_IS_CAPSFILTER</NAME>
#define GST_IS_CAPSFILTER(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CAPSFILTER))
</MACRO>
<MACRO>
<NAME>GST_IS_CAPSFILTER_CLASS</NAME>
#define GST_IS_CAPSFILTER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CAPSFILTER))
</MACRO>
<STRUCT>
<NAME>GstCapsFilter</NAME>
</STRUCT>
<STRUCT>
<NAME>GstCapsFilterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstCapsFilter</NAME>
struct _GstCapsFilter {
  GstBaseTransform trans;

  GstCaps *filter_caps;
};

</STRUCT>
<STRUCT>
<NAME>GstCapsFilterClass</NAME>
struct _GstCapsFilterClass {
  GstBaseTransformClass trans_class;
};

</STRUCT>
<FUNCTION>
<NAME>gst_capsfilter_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GstFakeSrcOutputType</NAME>
typedef enum {
  FAKE_SRC_FIRST_LAST_LOOP = 1,
  FAKE_SRC_LAST_FIRST_LOOP,
  FAKE_SRC_PING_PONG,
  FAKE_SRC_ORDERED_RANDOM,
  FAKE_SRC_RANDOM,
  FAKE_SRC_PATTERN_LOOP,
  FAKE_SRC_PING_PONG_PATTERN,
  FAKE_SRC_GET_ALWAYS_SUCEEDS
} GstFakeSrcOutputType;
</ENUM>
<ENUM>
<NAME>GstFakeSrcDataType</NAME>
typedef enum {
  FAKE_SRC_DATA_ALLOCATE = 1,
  FAKE_SRC_DATA_SUBBUFFER
} GstFakeSrcDataType;
</ENUM>
<ENUM>
<NAME>GstFakeSrcSizeType</NAME>
typedef enum {
  FAKE_SRC_SIZETYPE_EMPTY = 1,
  FAKE_SRC_SIZETYPE_FIXED,
  FAKE_SRC_SIZETYPE_RANDOM
} GstFakeSrcSizeType;
</ENUM>
<ENUM>
<NAME>GstFakeSrcFillType</NAME>
typedef enum {
  FAKE_SRC_FILLTYPE_NOTHING = 1,
  FAKE_SRC_FILLTYPE_ZERO,
  FAKE_SRC_FILLTYPE_RANDOM,
  FAKE_SRC_FILLTYPE_PATTERN,
  FAKE_SRC_FILLTYPE_PATTERN_CONT
} GstFakeSrcFillType;
</ENUM>
<MACRO>
<NAME>GST_TYPE_FAKE_SRC</NAME>
#define GST_TYPE_FAKE_SRC \
  (gst_fake_src_get_type())
</MACRO>
<MACRO>
<NAME>GST_FAKE_SRC</NAME>
#define GST_FAKE_SRC(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FAKE_SRC,GstFakeSrc))
</MACRO>
<MACRO>
<NAME>GST_FAKE_SRC_CLASS</NAME>
#define GST_FAKE_SRC_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FAKE_SRC,GstFakeSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKE_SRC</NAME>
#define GST_IS_FAKE_SRC(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FAKE_SRC))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKE_SRC_CLASS</NAME>
#define GST_IS_FAKE_SRC_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKE_SRC))
</MACRO>
<STRUCT>
<NAME>GstFakeSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSrc</NAME>
struct _GstFakeSrc {
  GstBaseSrc     element;

  /*< private >*/
  gboolean	 has_loop;
  gboolean	 has_getrange;

  GstFakeSrcOutputType output;
  GstFakeSrcDataType   data;
  GstFakeSrcSizeType   sizetype;
  GstFakeSrcFillType   filltype;

  guint		sizemin;
  guint		sizemax;
  GstBuffer	*parent;
  guint		parentsize;
  guint		parentoffset;
  guint8	 pattern_byte;
  gchar		*pattern;
  GList		*patternlist;
  gint		 datarate;
  gboolean	 sync;
  GstClock	*clock;

  gint		 num_buffers;
  gint		 rt_num_buffers; /* we are going to change this at runtime */
  gint64	 buffer_count;
  gboolean	 silent;
  gboolean	 signal_handoffs;
  gboolean	 dump;
  gboolean	 can_activate_pull;
  GstFormat      format;

  guint64        bytes_sent;

  gchar		*last_message;
};

</STRUCT>
<STRUCT>
<NAME>GstFakeSrcClass</NAME>
struct _GstFakeSrcClass {
  GstBaseSrcClass parent_class;

  /*< public >*/
  /* signals */
  void (*handoff) (GstElement *element, GstBuffer *buf, GstPad *pad);
};

</STRUCT>
<FUNCTION>
<NAME>gst_fake_src_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FAKE_SINK</NAME>
#define GST_TYPE_FAKE_SINK \
  (gst_fake_sink_get_type())
</MACRO>
<MACRO>
<NAME>GST_FAKE_SINK</NAME>
#define GST_FAKE_SINK(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FAKE_SINK,GstFakeSink))
</MACRO>
<MACRO>
<NAME>GST_FAKE_SINK_CLASS</NAME>
#define GST_FAKE_SINK_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FAKE_SINK,GstFakeSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKE_SINK</NAME>
#define GST_IS_FAKE_SINK(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FAKE_SINK))
</MACRO>
<MACRO>
<NAME>GST_IS_FAKE_SINK_CLASS</NAME>
#define GST_IS_FAKE_SINK_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKE_SINK))
</MACRO>
<MACRO>
<NAME>GST_FAKE_SINK_CAST</NAME>
#define GST_FAKE_SINK_CAST(obj) ((GstFakeSink *)obj)
</MACRO>
<ENUM>
<NAME>GstFakeSinkStateError</NAME>
typedef enum {
  FAKE_SINK_STATE_ERROR_NONE = 0,
  FAKE_SINK_STATE_ERROR_NULL_READY,
  FAKE_SINK_STATE_ERROR_READY_PAUSED,
  FAKE_SINK_STATE_ERROR_PAUSED_PLAYING,
  FAKE_SINK_STATE_ERROR_PLAYING_PAUSED,
  FAKE_SINK_STATE_ERROR_PAUSED_READY,
  FAKE_SINK_STATE_ERROR_READY_NULL
} GstFakeSinkStateError;
</ENUM>
<STRUCT>
<NAME>GstFakeSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFakeSink</NAME>
struct _GstFakeSink {
  GstBaseSink		element;

  gboolean		silent;
  gboolean		dump;
  gboolean		signal_handoffs;
  GstFakeSinkStateError state_error;
  gchar			*last_message;
  gint                  num_buffers;
  gint                  num_buffers_left;
  GStaticRecMutex       notify_lock;
};

</STRUCT>
<STRUCT>
<NAME>GstFakeSinkClass</NAME>
struct _GstFakeSinkClass {
  GstBaseSinkClass parent_class;

  /* signals */
  void (*handoff) (GstElement *element, GstBuffer *buf, GstPad *pad);
  void (*preroll_handoff) (GstElement *element, GstBuffer *buf, GstPad *pad);
};

</STRUCT>
<FUNCTION>
<NAME>gst_fake_sink_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FD_SINK</NAME>
#define GST_TYPE_FD_SINK \
  (gst_fd_sink_get_type())
</MACRO>
<MACRO>
<NAME>GST_FD_SINK</NAME>
#define GST_FD_SINK(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FD_SINK,GstFdSink))
</MACRO>
<MACRO>
<NAME>GST_FD_SINK_CLASS</NAME>
#define GST_FD_SINK_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FD_SINK,GstFdSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FD_SINK</NAME>
#define GST_IS_FD_SINK(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FD_SINK))
</MACRO>
<MACRO>
<NAME>GST_IS_FD_SINK_CLASS</NAME>
#define GST_IS_FD_SINK_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FD_SINK))
</MACRO>
<STRUCT>
<NAME>GstFdSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSink</NAME>
struct _GstFdSink {
  GstBaseSink parent;

  gchar *uri;

  GstPoll *fdset;

  int fd;
  guint64 bytes_written;
  guint64 current_pos;
};

</STRUCT>
<STRUCT>
<NAME>GstFdSinkClass</NAME>
struct _GstFdSinkClass {
  GstBaseSinkClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>gst_fd_sink_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FD_SRC</NAME>
#define GST_TYPE_FD_SRC \
  (gst_fd_src_get_type())
</MACRO>
<MACRO>
<NAME>GST_FD_SRC</NAME>
#define GST_FD_SRC(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FD_SRC,GstFdSrc))
</MACRO>
<MACRO>
<NAME>GST_FD_SRC_CLASS</NAME>
#define GST_FD_SRC_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FD_SRC,GstFdSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FD_SRC</NAME>
#define GST_IS_FD_SRC(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FD_SRC))
</MACRO>
<MACRO>
<NAME>GST_IS_FD_SRC_CLASS</NAME>
#define GST_IS_FD_SRC_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FD_SRC))
</MACRO>
<STRUCT>
<NAME>GstFdSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFdSrc</NAME>
struct _GstFdSrc {
  GstPushSrc element;

  /*< private >*/
  /* new_fd is copied to fd on READY->PAUSED */
  gint new_fd;

  /* fd and flag indicating whether fd is seekable */
  gint fd;
  gboolean seekable_fd;

  /* poll timeout */
  guint64 timeout;

  gchar *uri;

  GstPoll *fdset;

  gulong curoffset; /* current offset in file */
};

</STRUCT>
<STRUCT>
<NAME>GstFdSrcClass</NAME>
struct _GstFdSrcClass {
  GstPushSrcClass parent_class;

  /* signals */
  void (*timeout) (GstElement *element);
};

</STRUCT>
<FUNCTION>
<NAME>gst_fd_src_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FILE_SRC</NAME>
#define GST_TYPE_FILE_SRC \
  (gst_file_src_get_type())
</MACRO>
<MACRO>
<NAME>GST_FILE_SRC</NAME>
#define GST_FILE_SRC(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FILE_SRC,GstFileSrc))
</MACRO>
<MACRO>
<NAME>GST_FILE_SRC_CLASS</NAME>
#define GST_FILE_SRC_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FILE_SRC,GstFileSrcClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FILE_SRC</NAME>
#define GST_IS_FILE_SRC(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FILE_SRC))
</MACRO>
<MACRO>
<NAME>GST_IS_FILE_SRC_CLASS</NAME>
#define GST_IS_FILE_SRC_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FILE_SRC))
</MACRO>
<STRUCT>
<NAME>GstFileSrc</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFileSrcClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFileSrc</NAME>
struct _GstFileSrc {
  GstBaseSrc element;

  /*< private >*/
  guint pagesize;			/* system page size */

  gchar *filename;			/* filename */
  gchar *uri;				/* caching the URI */
  gint fd;				/* open file descriptor */
  guint64 read_position;		/* position of fd */

  gboolean touch;			/* whether to touch every page */
  gboolean using_mmap;                  /* whether we opened it with mmap */
  gboolean sequential;                  /* Whether to madvise (MADV_SEQUENTIAL) 
                                           for mmap pages */
  gboolean seekable;                    /* whether the file is seekable */
  gboolean is_regular;                  /* whether it's a (symlink to a)
                                           regular file */
  GstBuffer *mapbuf;
  size_t mapsize;
  gboolean use_mmap;
};

</STRUCT>
<STRUCT>
<NAME>GstFileSrcClass</NAME>
struct _GstFileSrcClass {
  GstBaseSrcClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>gst_file_src_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_FILE_SINK</NAME>
#define GST_TYPE_FILE_SINK \
  (gst_file_sink_get_type())
</MACRO>
<MACRO>
<NAME>GST_FILE_SINK</NAME>
#define GST_FILE_SINK(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FILE_SINK,GstFileSink))
</MACRO>
<MACRO>
<NAME>GST_FILE_SINK_CLASS</NAME>
#define GST_FILE_SINK_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FILE_SINK,GstFileSinkClass))
</MACRO>
<MACRO>
<NAME>GST_IS_FILE_SINK</NAME>
#define GST_IS_FILE_SINK(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FILE_SINK))
</MACRO>
<MACRO>
<NAME>GST_IS_FILE_SINK_CLASS</NAME>
#define GST_IS_FILE_SINK_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FILE_SINK))
</MACRO>
<STRUCT>
<NAME>GstFileSink</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFileSinkClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstFileSink</NAME>
struct _GstFileSink {
  GstBaseSink parent;

  /*< private >*/
  gchar *filename;
  gchar *uri;
  FILE *file;

  gboolean seekable;
  guint64 current_pos;

  gint    buffer_mode;
  guint   buffer_size;
  gchar  *buffer;
  
  gboolean append;
};

</STRUCT>
<STRUCT>
<NAME>GstFileSinkClass</NAME>
struct _GstFileSinkClass {
  GstBaseSinkClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>gst_file_sink_get_type</NAME>
<RETURNS>GType </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) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IDENTITY,GstIdentity))
</MACRO>
<MACRO>
<NAME>GST_IDENTITY_CLASS</NAME>
#define GST_IDENTITY_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_IDENTITY,GstIdentityClass))
</MACRO>
<MACRO>
<NAME>GST_IS_IDENTITY</NAME>
#define GST_IS_IDENTITY(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IDENTITY))
</MACRO>
<MACRO>
<NAME>GST_IS_IDENTITY_CLASS</NAME>
#define GST_IS_IDENTITY_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IDENTITY))
</MACRO>
<STRUCT>
<NAME>GstIdentity</NAME>
</STRUCT>
<STRUCT>
<NAME>GstIdentityClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstIdentity</NAME>
struct _GstIdentity {
  GstBaseTransform 	 element;

  /*< private >*/
  GstClockID     clock_id;
  gint 	 	 error_after;
  gfloat 	 drop_probability;
  gint		 datarate;
  guint 	 sleep_time;
  gboolean 	 silent;
  gboolean 	 dump;
  gboolean 	 sync;
  gboolean 	 check_perfect;
  gboolean 	 check_imperfect_timestamp;
  gboolean 	 check_imperfect_offset;
  gboolean	 single_segment;
  GstClockTime   prev_timestamp;
  GstClockTime   prev_duration;
  guint64        prev_offset;
  guint64        prev_offset_end;
  gchar 	*last_message;
  guint64        offset;
  gboolean       signal_handoffs;
  GStaticRecMutex  notify_lock;
};

</STRUCT>
<STRUCT>
<NAME>GstIdentityClass</NAME>
struct _GstIdentityClass {
  GstBaseTransformClass parent_class;

  /* signals */
  void (*handoff) (GstElement *element, GstBuffer *buf);
};

</STRUCT>
<FUNCTION>
<NAME>gst_identity_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_MULTI_QUEUE</NAME>
#define GST_TYPE_MULTI_QUEUE \
  (gst_multi_queue_get_type())
</MACRO>
<MACRO>
<NAME>GST_MULTI_QUEUE</NAME>
#define GST_MULTI_QUEUE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MULTI_QUEUE,GstMultiQueue))
</MACRO>
<MACRO>
<NAME>GST_MULTI_QUEUE_CLASS</NAME>
#define GST_MULTI_QUEUE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MULTI_QUEUE,GstMultiQueueClass))
</MACRO>
<MACRO>
<NAME>GST_IS_MULTI_QUEUE</NAME>
#define GST_IS_MULTI_QUEUE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MULTI_QUEUE))
</MACRO>
<MACRO>
<NAME>GST_IS_MULTI_QUEUE_CLASS</NAME>
#define GST_IS_MULTI_QUEUE_CLASS(obj) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MULTI_QUEUE))
</MACRO>
<STRUCT>
<NAME>GstMultiQueue</NAME>
</STRUCT>
<STRUCT>
<NAME>GstMultiQueueClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstMultiQueue</NAME>
struct _GstMultiQueue {
  GstElement element;

  /* number of queues */
  guint	nbqueues;

  /* The list of individual queues */
  GList *queues;
  guint32 queues_cookie;

  GstDataQueueSize  max_size, extra_size;

  guint32  counter;	/* incoming object counter */
  guint32  highid;	/* contains highest id of last outputted object */

  GMutex * qlock;	/* Global queue lock (vs object lock or individual */
			/* queues lock). Protects nbqueues, queues, global */
			/* GstMultiQueueSize, counter and highid */

  gint nextnotlinked;	/* ID of the next queue not linked (-1 : none) */

  gint numwaiting;	/* number of not-linked pads waiting */
};

</STRUCT>
<STRUCT>
<NAME>GstMultiQueueClass</NAME>
struct _GstMultiQueueClass {
  GstElementClass parent_class;

  /* signals emitted when ALL queues are either full or empty */
  void (*underrun)	(GstMultiQueue *queue);
  void (*overrun)	(GstMultiQueue *queue);
};

</STRUCT>
<FUNCTION>
<NAME>gst_multi_queue_get_type</NAME>
<RETURNS>GType </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) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_QUEUE,GstQueue))
</MACRO>
<MACRO>
<NAME>GST_QUEUE_CLASS</NAME>
#define GST_QUEUE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_QUEUE,GstQueueClass))
</MACRO>
<MACRO>
<NAME>GST_IS_QUEUE</NAME>
#define GST_IS_QUEUE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_QUEUE))
</MACRO>
<MACRO>
<NAME>GST_IS_QUEUE_CLASS</NAME>
#define GST_IS_QUEUE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QUEUE))
</MACRO>
<STRUCT>
<NAME>GstQueue</NAME>
</STRUCT>
<STRUCT>
<NAME>GstQueueSize</NAME>
</STRUCT>
<STRUCT>
<NAME>GstQueueClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstQueueSize</NAME>
struct _GstQueueSize {
    guint   buffers;
    guint   bytes;
    guint64 time;
};

</STRUCT>
<MACRO>
<NAME>GST_QUEUE_CLEAR_LEVEL</NAME>
#define GST_QUEUE_CLEAR_LEVEL(l) G_STMT_START {         \
  l.buffers = 0;                                        \
  l.bytes = 0;                                          \
  l.time = 0;                                           \
} G_STMT_END
</MACRO>
<STRUCT>
<NAME>GstQueue</NAME>
struct _GstQueue {
  GstElement element;

  /*< private >*/
  GstPad *sinkpad;
  GstPad *srcpad;

  /* segments to keep track of timestamps */
  GstSegment sink_segment;
  GstSegment src_segment;

  /* flowreturn when srcpad is paused */
  GstFlowReturn srcresult;
  gboolean      unexpected;
  gboolean      eos;

  /* the queue of data we're keeping our grubby hands on */
  GQueue *queue;

  GstQueueSize
    cur_level,          /* currently in the queue */
    max_size,           /* max. amount of data allowed in the queue */
    min_threshold,      /* min. amount of data required to wake reader */
    orig_min_threshold; /* Original min.threshold, for reset in EOS */

  /* whether we leak data, and at which end */
  gint leaky;

  GMutex *qlock;        /* lock for queue (vs object lock) */
  GCond *item_add;      /* signals buffers now available for reading */
  GCond *item_del;      /* signals space now available for writing */

  gboolean head_needs_discont, tail_needs_discont;
};

</STRUCT>
<STRUCT>
<NAME>GstQueueClass</NAME>
struct _GstQueueClass {
  GstElementClass parent_class;

  /* signals - 'running' is called from both sides
   * which might make it sort of non-useful... */
  void (*underrun)      (GstQueue *queue);
  void (*running)       (GstQueue *queue);
  void (*overrun)       (GstQueue *queue);

  void (*pushing)       (GstQueue *queue);
};

</STRUCT>
<FUNCTION>
<NAME>gst_queue_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GST_TYPE_TYPE_FIND_ELEMENT</NAME>
#define GST_TYPE_TYPE_FIND_ELEMENT		(gst_type_find_element_get_type ())
</MACRO>
<MACRO>
<NAME>GST_TYPE_FIND_ELEMENT</NAME>
#define GST_TYPE_FIND_ELEMENT(obj) 		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_TYPE_FIND_ELEMENT, GstTypeFindElement))
</MACRO>
<MACRO>
<NAME>GST_IS_TYPE_FIND_ELEMENT</NAME>
#define GST_IS_TYPE_FIND_ELEMENT(obj) 		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_TYPE_FIND_ELEMENT))
</MACRO>
<MACRO>
<NAME>GST_TYPE_FIND_ELEMENT_CLASS</NAME>
#define GST_TYPE_FIND_ELEMENT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_TYPE_FIND_ELEMENT, GstTypeFindElementClass))
</MACRO>
<MACRO>
<NAME>GST_IS_TYPE_FIND_ELEMENT_CLASS</NAME>
#define GST_IS_TYPE_FIND_ELEMENT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_TYPE_FIND_ELEMENT))
</MACRO>
<MACRO>
<NAME>GST_TYPE_FIND_ELEMENT_GET_CLASS</NAME>
#define GST_TYPE_FIND_ELEMENT_GET_CLASS(obj) 	(G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_TYPE_FIND_ELEMENT, GstTypeFindElementClass))
</MACRO>
<STRUCT>
<NAME>GstTypeFindElement</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTypeFindElementClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTypeFindElement</NAME>
struct _GstTypeFindElement {
  GstElement		element;

  GstPad *		sink;
  GstPad *		src;

  guint			min_probability;
  guint			max_probability;
  GstCaps *		caps;

  guint			mode;
  GstBuffer *		store;

  GList *               cached_events;
  GstCaps *             force_caps;
};

</STRUCT>
<STRUCT>
<NAME>GstTypeFindElementClass</NAME>
struct _GstTypeFindElementClass {
  GstElementClass 	parent_class;

  /* signals */
  void 			(*have_type) 	(GstTypeFindElement *element,
					 guint		probability,
					 const GstCaps *	caps);
};

</STRUCT>
<FUNCTION>
<NAME>gst_type_find_element_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</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) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_TEE,GstTee))
</MACRO>
<MACRO>
<NAME>GST_TEE_CLASS</NAME>
#define GST_TEE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_TEE,GstTeeClass))
</MACRO>
<MACRO>
<NAME>GST_IS_TEE</NAME>
#define GST_IS_TEE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_TEE))
</MACRO>
<MACRO>
<NAME>GST_IS_TEE_CLASS</NAME>
#define GST_IS_TEE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_TEE))
</MACRO>
<STRUCT>
<NAME>GstTee</NAME>
</STRUCT>
<STRUCT>
<NAME>GstTeeClass</NAME>
</STRUCT>
<ENUM>
<NAME>GstTeePullMode</NAME>
typedef enum {
  GST_TEE_PULL_MODE_NEVER,
  GST_TEE_PULL_MODE_SINGLE,
} GstTeePullMode;
</ENUM>
<STRUCT>
<NAME>GstTee</NAME>
struct _GstTee {
  GstElement      element;

  /*< private >*/
  /* lock protecting dynamic pads */
  GMutex         *dyn_lock;

  GstPad         *sinkpad;
  GstPad         *allocpad;
  gint            pad_counter;

  gboolean        has_chain;
  gboolean        has_sink_loop;
  gboolean        silent;
  gchar          *last_message;

  guint64         offset;
  GstActivateMode sink_mode;
  GstTeePullMode  pull_mode;
  GstPad         *pull_pad;
};

</STRUCT>
<STRUCT>
<NAME>GstTeeClass</NAME>
struct _GstTeeClass {
  GstElementClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>gst_tee_get_type</NAME>
<RETURNS>GType 	</RETURNS>
void
</FUNCTION>
