<STRUCT>
<NAME>AlsaCard</NAME>
struct AlsaCard
{
	SndCard parent;
	gchar *pcmdev;
	snd_pcm_t read_handle;
	snd_pcm_t write_handle;
	gint frame_size;
	gint frames;
	
};
</STRUCT>
<STRUCT>
<NAME>AlsaCard</NAME>
</STRUCT>
<FUNCTION>
<NAME>alsa_card_new</NAME>
<RETURNS>SndCard  *</RETURNS>
gint dev_id
</FUNCTION>
<STRUCT>
<NAME>AudioStream</NAME>
struct AudioStream
{
	MSSync *timer;
	RtpSession *send_session;
	RtpSession *recv_session;
	MSFilter *soundread;
	MSFilter *soundwrite;
	MSFilter *encoder;
	MSFilter *decoder;
	MSFilter *rtprecv;
	MSFilter *rtpsend;
};
</STRUCT>
<STRUCT>
<NAME>AudioStream</NAME>
</STRUCT>
<STRUCT>
<NAME>RingStream</NAME>
struct RingStream
{
	MSSync *timer;
	MSFilter *source;
	MSFilter *sndwrite;
};
</STRUCT>
<STRUCT>
<NAME>RingStream</NAME>
</STRUCT>
<FUNCTION>
<NAME>audio_stream_start</NAME>
<RETURNS>AudioStream  *</RETURNS>
RtpProfile * prof, int locport, char *remip4,int remport, int profile, int jitt_comp
</FUNCTION>
<FUNCTION>
<NAME>audio_stream_start_with_sndcard</NAME>
<RETURNS>AudioStream  *</RETURNS>
RtpProfile * prof, int locport, char *remip4,int remport, int profile, int jitt_comp, SndCard *sndcard
</FUNCTION>
<FUNCTION>
<NAME>audio_stream_start_with_files</NAME>
<RETURNS>AudioStream  *</RETURNS>
RtpProfile * prof, int locport,char *remip4, int remport,int profile, int jitt_comp,gchar * infile, gchar * outfile, SndCard *sndcard
</FUNCTION>
<FUNCTION>
<NAME>audio_stream_stop</NAME>
<RETURNS>void  </RETURNS>
AudioStream * stream
</FUNCTION>
<FUNCTION>
<NAME>ring_start</NAME>
<RETURNS>RingStream  *</RETURNS>
gchar * file, gint interval, SndCard *sndcard
</FUNCTION>
<FUNCTION>
<NAME>ring_stop</NAME>
<RETURNS>void  </RETURNS>
RingStream * stream
</FUNCTION>
<FUNCTION>
<NAME>test_audio_dev</NAME>
<RETURNS>gint  </RETURNS>
int dev_id
</FUNCTION>
<FUNCTION>
<NAME>send_dtmf</NAME>
<RETURNS>gint  </RETURNS>
AudioStream * stream, gchar dtmf
</FUNCTION>
<STRUCT>
<NAME>VideoStream</NAME>
struct VideoStream
{
	MSSync *timer;
	RtpSession *send_session;
	RtpSession *recv_session;
	MSFilter *source;
	MSFilter *dispatcher;
	MSFilter *mpegwrite;
	MSFilter *encoder;
	MSFilter *decoder;
	MSFilter *rtprecv;
	MSFilter *rtpsend;
};
</STRUCT>
<STRUCT>
<NAME>VideoStream</NAME>
</STRUCT>
<FUNCTION>
<NAME>video_stream_start_full</NAME>
<RETURNS>VideoStream  *</RETURNS>
int locport, char *remip4, int remport,int profile, int jitt_comp,gchar * infile, gchar * outfile
</FUNCTION>
<FUNCTION>
<NAME>video_stream_stop</NAME>
<RETURNS>void  </RETURNS>
VideoStream * stream
</FUNCTION>
<FUNCTION>
<NAME>ms_init</NAME>
<RETURNS>void  </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_compile</NAME>
<RETURNS>int  </RETURNS>
MSSync *source
</FUNCTION>
<FUNCTION>
<NAME>ms_thread_stop</NAME>
<RETURNS>void  </RETURNS>
MSSync *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_thread_run</NAME>
<RETURNS>void  *</RETURNS>
void *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_start</NAME>
<RETURNS>void  </RETURNS>
MSSync *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_stop</NAME>
<RETURNS>void  </RETURNS>
MSSync *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_proc_get_param</NAME>
<RETURNS>gchar  *</RETURNS>
gchar *parameter
</FUNCTION>
<FUNCTION>
<NAME>ms_proc_get_type</NAME>
<RETURNS>gint  </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_proc_get_speed</NAME>
<RETURNS>gint  </RETURNS>

</FUNCTION>
<MACRO>
<NAME>MSALAWDECODER_MAX_INPUTS</NAME>
#define MSALAWDECODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_ALAWDECODER</NAME>
#define MS_ALAWDECODER(filter) ((MSALAWDecoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_ALAWDECODER_CLASS</NAME>
#define MS_ALAWDECODER_CLASS(klass) ((MSALAWDecoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_ALAWdecoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWdecoder_init</NAME>
<RETURNS>void  </RETURNS>
MSALAWDecoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWdecoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSALAWDecoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWdecoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSALAWDecoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWdecoder_process</NAME>
<RETURNS>void  </RETURNS>
MSALAWDecoder *r
</FUNCTION>
<MACRO>
<NAME>ALAW_DECODER_WMAXGRAN</NAME>
#define ALAW_DECODER_WMAXGRAN 320
</MACRO>
<MACRO>
<NAME>ALAW_DECODER_RMAXGRAN</NAME>
#define ALAW_DECODER_RMAXGRAN 160
</MACRO>
<VARIABLE>
<NAME>ALAWinfo</NAME>
extern MSCodecInfo ALAWinfo;
</VARIABLE>
<MACRO>
<NAME>MSALAWENCODER_MAX_INPUTS</NAME>
#define MSALAWENCODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_ALAWENCODER</NAME>
#define MS_ALAWENCODER(filter) ((MSALAWEncoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_ALAWENCODER_CLASS</NAME>
#define MS_ALAWENCODER_CLASS(klass) ((MSALAWEncoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_ALAWencoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWencoder_init</NAME>
<RETURNS>void  </RETURNS>
MSALAWEncoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWencoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSALAWEncoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWencoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSALAWEncoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_ALAWencoder_process</NAME>
<RETURNS>void  </RETURNS>
MSALAWEncoder *r
</FUNCTION>
<MACRO>
<NAME>ALAW_ENCODER_WMAXGRAN</NAME>
#define ALAW_ENCODER_WMAXGRAN 160
</MACRO>
<MACRO>
<NAME>ALAW_ENCODER_RMAXGRAN</NAME>
#define ALAW_ENCODER_RMAXGRAN 320
</MACRO>
<MACRO>
<NAME>MSGSMDECODER_MAX_INPUTS</NAME>
#define MSGSMDECODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_GSMDECODER</NAME>
#define MS_GSMDECODER(filter) ((MSGSMDecoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_GSMDECODER_CLASS</NAME>
#define MS_GSMDECODER_CLASS(klass) ((MSGSMDecoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_GSMdecoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMdecoder_init</NAME>
<RETURNS>void  </RETURNS>
MSGSMDecoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMdecoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSGSMDecoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMdecoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSGSMDecoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMdecoder_process</NAME>
<RETURNS>void  </RETURNS>
MSGSMDecoder *r
</FUNCTION>
<VARIABLE>
<NAME>GSMinfo</NAME>
extern MSCodecInfo GSMinfo;
</VARIABLE>
<MACRO>
<NAME>MSGSMENCODER_MAX_INPUTS</NAME>
#define MSGSMENCODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_GSMENCODER</NAME>
#define MS_GSMENCODER(filter) ((MSGSMEncoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_GSMENCODER_CLASS</NAME>
#define MS_GSMENCODER_CLASS(klass) ((MSGSMEncoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_GSMencoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMencoder_init</NAME>
<RETURNS>void  </RETURNS>
MSGSMEncoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMencoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSGSMEncoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMencoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSGSMEncoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_GSMencoder_process</NAME>
<RETURNS>void  </RETURNS>
MSGSMEncoder *r
</FUNCTION>
<MACRO>
<NAME>MSLPC10DECODER_MAX_INPUTS</NAME>
#define MSLPC10DECODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_LPC10DECODER</NAME>
#define MS_LPC10DECODER(filter) ((MSLPC10Decoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_LPC10DECODER_CLASS</NAME>
#define MS_LPC10DECODER_CLASS(klass) ((MSLPC10DecoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_LPC10decoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10decoder_init</NAME>
<RETURNS>void  </RETURNS>
MSLPC10Decoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10decoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSLPC10DecoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10decoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSLPC10Decoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10decoder_process</NAME>
<RETURNS>void  </RETURNS>
MSLPC10Decoder *r
</FUNCTION>
<VARIABLE>
<NAME>LPC10info</NAME>
extern MSCodecInfo LPC10info;
</VARIABLE>
<FUNCTION>
<NAME>read_16bit_samples</NAME>
<RETURNS>int</RETURNS>
gint16 int16samples[], float speech[], int n
</FUNCTION>
<FUNCTION>
<NAME>write_16bit_samples</NAME>
<RETURNS>int</RETURNS>
gint16 int16samples[], float speech[], int n
</FUNCTION>
<FUNCTION>
<NAME>write_bits</NAME>
<RETURNS>void</RETURNS>
unsigned char *data, gint32 *bits, int len
</FUNCTION>
<FUNCTION>
<NAME>read_bits</NAME>
<RETURNS>int</RETURNS>
unsigned char *data, gint32 *bits, int len
</FUNCTION>
<MACRO>
<NAME>MSLPC10ENCODER_MAX_INPUTS</NAME>
#define MSLPC10ENCODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_LPC10ENCODER</NAME>
#define MS_LPC10ENCODER(filter) ((MSLPC10Encoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_LPC10ENCODER_CLASS</NAME>
#define MS_LPC10ENCODER_CLASS(klass) ((MSLPC10EncoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_LPC10encoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10encoder_init</NAME>
<RETURNS>void  </RETURNS>
MSLPC10Encoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10encoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSLPC10EncoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10encoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSLPC10Encoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_LPC10encoder_process</NAME>
<RETURNS>void  </RETURNS>
MSLPC10Encoder *r
</FUNCTION>
<MACRO>
<NAME>MSMULAWDECODER_MAX_INPUTS</NAME>
#define MSMULAWDECODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_MULAWDECODER</NAME>
#define MS_MULAWDECODER(filter) ((MSMULAWDecoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_MULAWDECODER_CLASS</NAME>
#define MS_MULAWDECODER_CLASS(klass) ((MSMULAWDecoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_MULAWdecoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWdecoder_init</NAME>
<RETURNS>void  </RETURNS>
MSMULAWDecoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWdecoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSMULAWDecoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWdecoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSMULAWDecoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWdecoder_process</NAME>
<RETURNS>void  </RETURNS>
MSMULAWDecoder *r
</FUNCTION>
<MACRO>
<NAME>MULAW_DECODER_WMAXGRAN</NAME>
#define MULAW_DECODER_WMAXGRAN 320
</MACRO>
<MACRO>
<NAME>MULAW_DECODER_RMAXGRAN</NAME>
#define MULAW_DECODER_RMAXGRAN 160
</MACRO>
<VARIABLE>
<NAME>MULAWinfo</NAME>
extern MSCodecInfo MULAWinfo;
</VARIABLE>
<MACRO>
<NAME>MSMULAWENCODER_MAX_INPUTS</NAME>
#define MSMULAWENCODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_MULAWENCODER</NAME>
#define MS_MULAWENCODER(filter) ((MSMULAWEncoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_MULAWENCODER_CLASS</NAME>
#define MS_MULAWENCODER_CLASS(klass) ((MSMULAWEncoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_MULAWencoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWencoder_init</NAME>
<RETURNS>void  </RETURNS>
MSMULAWEncoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWencoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSMULAWEncoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWencoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSMULAWEncoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_MULAWencoder_process</NAME>
<RETURNS>void  </RETURNS>
MSMULAWEncoder *r
</FUNCTION>
<MACRO>
<NAME>MULAW_ENCODER_WMAXGRAN</NAME>
#define MULAW_ENCODER_WMAXGRAN 160
</MACRO>
<MACRO>
<NAME>MULAW_ENCODER_RMAXGRAN</NAME>
#define MULAW_ENCODER_RMAXGRAN 320
</MACRO>
<MACRO>
<NAME>AVCODEC_H</NAME>
#define AVCODEC_H
</MACRO>
<MACRO>
<NAME>MSAVDECODER_MAX_INPUTS</NAME>
#define MSAVDECODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<STRUCT>
<NAME>MSAVDecoder</NAME>
struct MSAVDecoder
{
    /* the MSAVDecoder derivates from MSFilter, so the MSFilter object MUST be the first of the MSAVDecoder object
       in order to the object mechanism to work*/
    MSFilter filter;
    MSQueue *q_inputs[MSAVDECODER_MAX_INPUTS];
    MSQueue *q_outputs[MSAVDECODER_MAX_INPUTS];
	AVCodec *av_codec;  /*the AVCodec from which this MSFilter is related */
	AVCodecContext av_context;  /* the context of the AVCodec */
	gint av_opened;
	int output_pix_fmt;
	int width;
	int height;
	MSBuffer obufwrap;		/* the static output MSBuffer */
	MSBuffer *obufwrap2;		/* alternate buffer, when format change is needed*/
};
</STRUCT>
<STRUCT>
<NAME>MSAVDecoder</NAME>
</STRUCT>
<STRUCT>
<NAME>MSAVDecoderClass</NAME>
struct MSAVDecoderClass
{
	/* the MSAVDecoder derivates from MSFilter, so the MSFilter class MUST be the first of the MSAVDecoder class
       in order to the class mechanism to work*/
	MSFilterClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSAVDecoderClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_AVDECODER</NAME>
#define MS_AVDECODER(filter) ((MSAVDecoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_AVDECODER_CLASS</NAME>
#define MS_AVDECODER_CLASS(klass) ((MSAVDecoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_h263decoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_mpeg_decoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_mpeg4_decoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_new_with_codec</NAME>
<RETURNS>MSFilter  *</RETURNS>
enum CodecID codec_id
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_set_format</NAME>
<RETURNS>gint  </RETURNS>
MSAVDecoder *dec, gchar *fmt
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_set_width</NAME>
<RETURNS>void  </RETURNS>
MSAVDecoder *av,gint w
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_set_height</NAME>
<RETURNS>void  </RETURNS>
MSAVDecoder *av,gint h
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_init</NAME>
<RETURNS>void  </RETURNS>
MSAVDecoder *r, AVCodec *codec
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_uninit</NAME>
<RETURNS>void  </RETURNS>
MSAVDecoder *enc
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSAVDecoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSAVDecoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_AVdecoder_process</NAME>
<RETURNS>void  </RETURNS>
MSAVDecoder *r
</FUNCTION>
<FUNCTION>
<NAME>ms_AVCodec_init</NAME>
<RETURNS>void  </RETURNS>

</FUNCTION>
<MACRO>
<NAME>AVCODEC_H</NAME>
#define AVCODEC_H
</MACRO>
<MACRO>
<NAME>MSAVENCODER_MAX_INPUTS</NAME>
#define MSAVENCODER_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<STRUCT>
<NAME>MSAVEncoder</NAME>
struct MSAVEncoder
{
    /* the MSAVEncoder derivates from MSFilter, so the MSFilter object MUST be the first of the MSAVEncoder object
       in order to the object mechanism to work*/
    MSFilter filter;
    MSQueue *q_inputs[MSAVENCODER_MAX_INPUTS];
    MSQueue *q_outputs[MSAVENCODER_MAX_INPUTS];
	AVCodec *av_codec;  /*the AVCodec from which this MSFilter is related */
	AVCodecContext av_context;  /* the context of the AVCodec */
	gint input_pix_fmt;
	gint av_opened;
	MSBuffer *tmpbuf;
};
</STRUCT>
<STRUCT>
<NAME>MSAVEncoder</NAME>
</STRUCT>
<STRUCT>
<NAME>MSAVEncoderClass</NAME>
struct MSAVEncoderClass
{
	/* the MSAVEncoder derivates from MSFilter, so the MSFilter class MUST be the first of the MSAVEncoder class
       in order to the class mechanism to work*/
	MSFilterClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSAVEncoderClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_AVENCODER</NAME>
#define MS_AVENCODER(filter) ((MSAVEncoder*)(filter))
</MACRO>
<MACRO>
<NAME>MS_AVENCODER_CLASS</NAME>
#define MS_AVENCODER_CLASS(klass) ((MSAVEncoderClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_h263_encoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_mpeg_encoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_mpeg4_encoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_AVencoder_new_with_codec</NAME>
<RETURNS>MSFilter  *</RETURNS>
enum CodecID codec_id
</FUNCTION>
<FUNCTION>
<NAME>ms_AVencoder_set_format</NAME>
<RETURNS>gint  </RETURNS>
MSAVEncoder *enc, gchar *fmt
</FUNCTION>
<MACRO>
<NAME>ms_AVencoder_set_width</NAME>
#define ms_AVencoder_set_width(av,w)	(av)->av_context.width=(w)
</MACRO>
<MACRO>
<NAME>ms_AVencoder_set_height</NAME>
#define ms_AVencoder_set_height(av,h)	(av)->av_context.height=(h)
</MACRO>
<MACRO>
<NAME>ms_AVencoder_set_frame_rate</NAME>
#define ms_AVencoder_set_frame_rate(av,r)	(av)->av_context.frame_rate=(r)*FRAME_RATE_BASE
</MACRO>
<MACRO>
<NAME>ms_AVencoder_set_bit_rate</NAME>
#define ms_AVencoder_set_bit_rate(av,r)		(av)->av_context.bit_rate=(r)
</MACRO>
<FUNCTION>
<NAME>ms_AVencoder_init</NAME>
<RETURNS>void  </RETURNS>
MSAVEncoder *r, AVCodec *codec
</FUNCTION>
<FUNCTION>
<NAME>ms_AVencoder_uninit</NAME>
<RETURNS>void  </RETURNS>
MSAVEncoder *enc
</FUNCTION>
<FUNCTION>
<NAME>ms_AVencoder_class_init</NAME>
<RETURNS>void  </RETURNS>
MSAVEncoderClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_AVencoder_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSAVEncoder *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_AVencoder_process</NAME>
<RETURNS>void  </RETURNS>
MSAVEncoder *r
</FUNCTION>
<MACRO>
<NAME>MS_BUFFER_LARGE</NAME>
#define MS_BUFFER_LARGE 4092
</MACRO>
<MACRO>
<NAME>MS_BUFFER_CONTIGUOUS</NAME>
#define MS_BUFFER_CONTIGUOUS (1)
</MACRO>
<FUNCTION>
<NAME>ms_buffer_new</NAME>
<RETURNS>MSBuffer  *</RETURNS>
guint32 size
</FUNCTION>
<FUNCTION>
<NAME>ms_buffer_destroy</NAME>
<RETURNS>void  </RETURNS>
MSBuffer *buf
</FUNCTION>
<STRUCT>
<NAME>MSMessage</NAME>
struct MSMessage
{
   MSBuffer *buffer; /* points to a MSBuffer */
   void *data;          /*points to buffer->buffer  */
   guint32 size;   /* the size of the buffer to read in data. It may not be the
   								physical size (I mean buffer->buffer->size */
   struct _MSMessage *next;
   struct _MSMessage *prev;  /* MSMessage are queued into MSQueues */
};
</STRUCT>
<STRUCT>
<NAME>MSMessage</NAME>
</STRUCT>
<FUNCTION>
<NAME>ms_buffer_alloc</NAME>
<RETURNS>MSBuffer  *</RETURNS>
gint flags
</FUNCTION>
<FUNCTION>
<NAME>ms_message_new</NAME>
<RETURNS>MSMessage  *</RETURNS>
gint size
</FUNCTION>
<MACRO>
<NAME>ms_message_set_buf</NAME>
#define ms_message_set_buf(m,b) do { (b)->ref_count++; (m)->buffer=(b); (m)->data=(b)->buffer; (m)->size=(b)->size; }while(0)
</MACRO>
<MACRO>
<NAME>ms_message_unset_buf</NAME>
#define ms_message_unset_buf(m) do { (m)->buffer->ref_count--; (m)->buffer=NULL; (m)->size=0; (m)->data=NULL; } while(0)
</MACRO>
<MACRO>
<NAME>ms_message_size</NAME>
#define ms_message_size(m)		(m)->size
</MACRO>
<FUNCTION>
<NAME>ms_message_destroy</NAME>
<RETURNS>void  </RETURNS>
MSMessage *m
</FUNCTION>
<FUNCTION>
<NAME>ms_message_dup</NAME>
<RETURNS>MSMessage  *</RETURNS>
MSMessage *m
</FUNCTION>
<FUNCTION>
<NAME>ms_message_alloc</NAME>
<RETURNS>MSMessage  *</RETURNS>

</FUNCTION>
<STRUCT>
<NAME>MSCodecInfo</NAME>
struct MSCodecInfo
{
	MSFilterInfo info;
	MSFilterNewFunc encoder;
	MSFilterNewFunc decoder;
	gint fr_size; /* size in char of the uncompressed frame */
	gint dt_size;	/* size in char of the compressed frame */
	gint bitrate;  /* the minimum bit rate in bits/second */
	gint rate;		/*frequency */
	gint pt;			/* the payload type number associated with this codec*/
	gchar *description;		/* a rtpmap field to describe the codec */
	guint is_usable:1; /* linphone set this flag to remember if it can use this codec considering the total bandwidth*/
	guint is_selected:1; /* linphone (user) set this flag if he allows this codec to be used*/
};
</STRUCT>
<STRUCT>
<NAME>MSCodecInfo</NAME>
</STRUCT>
<FUNCTION>
<NAME>ms_encoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ms_decoder_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ms_encoder_new_with_pt</NAME>
<RETURNS>MSFilter  *</RETURNS>
gint pt
</FUNCTION>
<FUNCTION>
<NAME>ms_decoder_new_with_pt</NAME>
<RETURNS>MSFilter  *</RETURNS>
gint pt
</FUNCTION>
<FUNCTION>
<NAME>ms_encoder_new_with_string_id</NAME>
<RETURNS>MSFilter  *</RETURNS>
gchar *id
</FUNCTION>
<FUNCTION>
<NAME>ms_decoder_new_with_string_id</NAME>
<RETURNS>MSFilter  *</RETURNS>
gchar *id
</FUNCTION>
<FUNCTION>
<NAME>ms_codec_is_usable</NAME>
<RETURNS>int  </RETURNS>
MSCodecInfo *codec,double bandwidth
</FUNCTION>
<FUNCTION>
<NAME>ms_codec_get_all_audio</NAME>
<RETURNS>GList  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_codec_get_all_video</NAME>
<RETURNS>GList  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_audio_codec_info_get</NAME>
<RETURNS>MSCodecInfo  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ms_video_codec_info_get</NAME>
<RETURNS>MSCodecInfo  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ms_codec_register_all</NAME>
<RETURNS>void  </RETURNS>

</FUNCTION>
<MACRO>
<NAME>MS_CODEC_INFO</NAME>
#define MS_CODEC_INFO(codinfo)	((MSCodecInfo*)codinfo)
</MACRO>
<MACRO>
<NAME>MSCOPY_MAX_INPUTS</NAME>
#define MSCOPY_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MSCOPY_DEF_GRAN</NAME>
#define MSCOPY_DEF_GRAN 64 /* the default granularity*/
</MACRO>
<MACRO>
<NAME>MS_COPY</NAME>
#define MS_COPY(filter) ((MSCopy*)(filter))
</MACRO>
<MACRO>
<NAME>MS_COPY_CLASS</NAME>
#define MS_COPY_CLASS(klass) ((MSCopyClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_copy_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_copy_init</NAME>
<RETURNS>void  </RETURNS>
MSCopy *r
</FUNCTION>
<FUNCTION>
<NAME>ms_copy_class_init</NAME>
<RETURNS>void  </RETURNS>
MSCopyClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_copy_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSCopy *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_copy_process</NAME>
<RETURNS>void  </RETURNS>
MSCopy *r
</FUNCTION>
<MACRO>
<NAME>MS_FDISPATCHER_MAX_INPUTS</NAME>
#define MS_FDISPATCHER_MAX_INPUTS  1
</MACRO>
<MACRO>
<NAME>MS_FDISPATCHER_MAX_OUTPUTS</NAME>
#define MS_FDISPATCHER_MAX_OUTPUTS 5 
</MACRO>
<MACRO>
<NAME>MS_FDISPATCHER_DEF_GRAN</NAME>
#define MS_FDISPATCHER_DEF_GRAN 64 /* the default granularity*/
</MACRO>
<MACRO>
<NAME>MS_FDISPATCHER</NAME>
#define MS_FDISPATCHER(filter) ((MSFdispatcher*)(filter))
</MACRO>
<MACRO>
<NAME>MS_FDISPATCHER_CLASS</NAME>
#define MS_FDISPATCHER_CLASS(klass) ((MSFdispatcherClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_fdispatcher_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_fdispatcher_init</NAME>
<RETURNS>void  </RETURNS>
MSFdispatcher *r
</FUNCTION>
<FUNCTION>
<NAME>ms_fdispatcher_class_init</NAME>
<RETURNS>void  </RETURNS>
MSFdispatcherClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_fdispatcher_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSFdispatcher *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_fdispatcher_process</NAME>
<RETURNS>void  </RETURNS>
MSFdispatcher *r
</FUNCTION>
<FUNCTION>
<NAME>ms_fifo_new</NAME>
<RETURNS>MSFifo  *</RETURNS>
MSBuffer *buf, gint r_gran, gint w_gran, gint r_offset, gint w_offset
</FUNCTION>
<FUNCTION>
<NAME>ms_fifo_new_with_buffer</NAME>
<RETURNS>MSFifo  *</RETURNS>
gint r_gran, gint w_gran, gint r_offset, gint w_offset, gint min_buffer_size
</FUNCTION>
<FUNCTION>
<NAME>ms_fifo_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSFifo *fifo
</FUNCTION>
<FUNCTION>
<NAME>ms_fifo_destroy_with_buffer</NAME>
<RETURNS>void  </RETURNS>
MSFifo *fifo
</FUNCTION>
<FUNCTION>
<NAME>ms_fifo_get_read_ptr</NAME>
<RETURNS>gint  </RETURNS>
MSFifo *fifo, gint bsize, void **ret_ptr
</FUNCTION>
<FUNCTION>
<NAME>ms_fifo_get_write_ptr</NAME>
<RETURNS>gint  </RETURNS>
MSFifo *fifo, gint bsize, void **ret_ptr
</FUNCTION>
<USER_FUNCTION>
<NAME>MSFilterNotifyFunc</NAME>
<RETURNS>gint </RETURNS>
struct _MSFilter*, gint event, gpointer arg, gpointer userdata
</USER_FUNCTION>
<STRUCT>
<NAME>MSFilter</NAME>
struct MSFilter
{
	struct _MSFilterClass *klass;
	GMutex *lock;
	guchar finputs;   /* number of connected fifo inputs*/
	guchar foutputs;  /* number of connected fifo outputs*/
	guchar qinputs;   /* number of connected queue inputs*/
	guchar qoutputs;  /* number of connected queue outputs*/
	gint min_fifo_size; /* set when linking*/
	gint r_mingran;				/* read minimum granularity (for fifos).
					It can be zero so that the filter can accept any size of reading data*/
	MSFifo **infifos; /*pointer to a table of pointer to input fifos*/
	MSFifo **outfifos;  /*pointer to a table of pointer to output fifos*/
	MSQueue **inqueues;  /*pointer to a table of pointer to input queues*/
	MSQueue **outqueues;  /*pointer to a table of pointer to output queues*/
	MSFilterNotifyFunc notify_event;
	gpointer userdata;
};
</STRUCT>
<STRUCT>
<NAME>MSFilter</NAME>
</STRUCT>
<ENUM>
<NAME>MSFilterProperty</NAME>
typedef enum{
	MS_FILTER_PROPERTY_FREQ,	/* value is int */
	MS_FILTER_PROPERTY_BITRATE, /*value is int */
	MS_FILTER_PROPERTY_FMTP    /* value is string */
}MSFilterProperty;
</ENUM>
<USER_FUNCTION>
<NAME>MSFilterNewFunc</NAME>
<RETURNS>MSFilter *</RETURNS>
void
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>MSFilterProcessFunc</NAME>
<RETURNS>void </RETURNS>
MSFilter *
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>MSFilterDestroyFunc</NAME>
<RETURNS>void </RETURNS>
MSFilter *
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>MSFilterPropertyFunc</NAME>
<RETURNS>int </RETURNS>
MSFilter *,int ,void*
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>MSFilterSetupFunc</NAME>
<RETURNS>void </RETURNS>
MSFilter *, void *
</USER_FUNCTION>
<STRUCT>
<NAME>MSFilterInfo</NAME>
struct MSFilterInfo *info;	/*pointer to a filter_info */
	gchar *name;
	guchar max_finputs;   /* maximum number of fifo inputs*/
	guchar max_foutputs;  /* maximum number of fifo outputs*/
	guchar max_qinputs;   /* maximum number of queue inputs*/
	guchar max_qoutputs;  /* maximum number of queue outputs*/
	gint r_maxgran;       /* read maximum granularity (for fifos)*/
	gint w_maxgran;				/* write maximum granularity (for fifos)*/
	gint r_offset;				/* size of kept samples behind read pointer (for fifos)*/
	gint w_offset;				/* size of kept samples behind write pointer (for fifos)*/
	MSFilterPropertyFunc set_property;
	MSFilterSetupFunc setup;	/* called when attaching to sync */
	void (*process)(MSFilter *filter);
	MSFilterSetupFunc unsetup;	/* called when detaching from sync */
	void (*destroy)(MSFilter *filter);
	guint attributes;
#define FILTER_HAS_FIFOS (0x0001)
#define FILTER_HAS_QUEUES (0x0001<<1)
#define FILTER_IS_SOURCE (0x0001<<2)
#define FILTER_IS_SINK (0x0001<<3)
#define FILTER_CAN_SYNC (0x0001<<4)
	guint ref_count; /*number of object using the class*/
} MSFilterClass;
</STRUCT>
<MACRO>
<NAME>MS_FILTER</NAME>
#define MS_FILTER(obj) ((MSFilter*)obj)
</MACRO>
<MACRO>
<NAME>MS_FILTER_CLASS</NAME>
#define MS_FILTER_CLASS(klass) ((MSFilterClass*)klass)
</MACRO>
<MACRO>
<NAME>MS_FILTER_GET_CLASS</NAME>
#define MS_FILTER_GET_CLASS(obj) ((MSFilterClass*)((MS_FILTER(obj)->klass)))
</MACRO>
<FUNCTION>
<NAME>ms_filter_class_init</NAME>
<RETURNS>void  </RETURNS>
MSFilterClass *filterclass
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_init</NAME>
<RETURNS>void  </RETURNS>
MSFilter *filter
</FUNCTION>
<MACRO>
<NAME>ms_filter_class_set_attr</NAME>
#define ms_filter_class_set_attr(filter,flag) ((filter)->attributes|=(flag))
</MACRO>
<MACRO>
<NAME>ms_filter_class_unset_attr</NAME>
#define ms_filter_class_unset_attr(filter,flag) ((filter)->attributes&=~(flag))
</MACRO>
<MACRO>
<NAME>ms_filter_class_set_name</NAME>
#define ms_filter_class_set_name(__klass,__name)  (__klass)->name=g_strdup((__name))
</MACRO>
<MACRO>
<NAME>ms_filter_class_set_info</NAME>
#define ms_filter_class_set_info(_klass,_info)	(_klass)->info=(_info)
</MACRO>
<MACRO>
<NAME>ms_filter_process</NAME>
#define  ms_filter_process(filter) ((filter)->klass->process((filter)))
</MACRO>
<MACRO>
<NAME>ms_filter_lock</NAME>
#define ms_filter_lock(filter)		g_mutex_lock((filter)->lock)
</MACRO>
<MACRO>
<NAME>ms_filter_unlock</NAME>
#define ms_filter_unlock(filter)	g_mutex_unlock((filter)->lock)
</MACRO>
<FUNCTION>
<NAME>ms_filter_link</NAME>
<RETURNS>int  </RETURNS>
MSFilter *m1, gint pin1, MSFilter *m2,gint pin2, gint linktype
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_unlink</NAME>
<RETURNS>int  </RETURNS>
MSFilter *m1, gint pin1, MSFilter *m2,gint pin2,gint linktype
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_add_link</NAME>
<RETURNS>int  </RETURNS>
MSFilter *m1, MSFilter *m2
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_remove_links</NAME>
<RETURNS>int  </RETURNS>
MSFilter *m1, MSFilter *m2
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_set_property</NAME>
<RETURNS>int  </RETURNS>
MSFilter *f,MSFilterProperty property, void *value
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_fifos_have_data</NAME>
<RETURNS>gint  </RETURNS>
MSFilter *f
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_queues_have_data</NAME>
<RETURNS>gint  </RETURNS>
MSFilter *f
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_uninit</NAME>
<RETURNS>void  </RETURNS>
MSFilter *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_destroy</NAME>
<RETURNS>void  </RETURNS>
MSFilter *f
</FUNCTION>
<MACRO>
<NAME>ms_filter_get_mingran</NAME>
#define ms_filter_get_mingran(f) ((f)->r_mingran)
</MACRO>
<MACRO>
<NAME>ms_filter_set_mingran</NAME>
#define ms_filter_set_mingran(f,gran) ((f)->r_mingran=(gran))
</MACRO>
<MACRO>
<NAME>LINK_DEFAULT</NAME>
#define LINK_DEFAULT 0
</MACRO>
<MACRO>
<NAME>LINK_FIFO</NAME>
#define LINK_FIFO 1
</MACRO>
<MACRO>
<NAME>LINK_QUEUE</NAME>
#define LINK_QUEUE 2
</MACRO>
<MACRO>
<NAME>MSFILTER_VERSION</NAME>
#define MSFILTER_VERSION(a,b,c) (((a)<<2)|((b)<<1)|(c))
</MACRO>
<FUNCTION>
<NAME>ms_filter_search_upstream_by_type</NAME>
<RETURNS>MSFilter  *</RETURNS>
MSFilter *f,MSFilterType type
</FUNCTION>
<STRUCT>
<NAME>MSFilterInfo</NAME>
struct MSFilterInfo
{
	gchar *name;
	gint version;
	MSFilterType type;
	MSFilterNewFunc constructor;
	char *description;  /*some textual information*/
};
</STRUCT>
<STRUCT>
<NAME>MSFilterInfo</NAME>
</STRUCT>
<FUNCTION>
<NAME>ms_filter_register</NAME>
<RETURNS>void  </RETURNS>
MSFilterInfo *finfo
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_unregister</NAME>
<RETURNS>void  </RETURNS>
MSFilterInfo *finfo
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_get_by_name</NAME>
<RETURNS>MSFilterInfo  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_new_with_name</NAME>
<RETURNS>MSFilter  *</RETURNS>
gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_set_notify_func</NAME>
<RETURNS>void  </RETURNS>
MSFilter* filter,MSFilterNotifyFunc func, gpointer userdata
</FUNCTION>
<FUNCTION>
<NAME>ms_filter_notify_event</NAME>
<RETURNS>void  </RETURNS>
MSFilter *filter,gint event, gpointer arg
</FUNCTION>
<VARIABLE>
<NAME>filter_list</NAME>
extern GList *filter_list;
</VARIABLE>
<MACRO>
<NAME>MS_FILTER_INFO</NAME>
#define MS_FILTER_INFO(obj)	((MSFilterInfo*)obj)
</MACRO>
<FUNCTION>
<NAME>swap_buffer</NAME>
<RETURNS>void  </RETURNS>
gchar *buffer, gint len
</FUNCTION>
<MACRO>
<NAME>MSNOSYNC_MAX_FILTERS</NAME>
#define MSNOSYNC_MAX_FILTERS 10
</MACRO>
<FUNCTION>
<NAME>ms_nosync_init</NAME>
<RETURNS>void  </RETURNS>
MSNoSync *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_nosync_class_init</NAME>
<RETURNS>void  </RETURNS>
MSNoSyncClass *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_nosync_destroy</NAME>
<RETURNS>void  </RETURNS>
MSNoSync *nosync
</FUNCTION>
<FUNCTION>
<NAME>ms_nosync_synchronize</NAME>
<RETURNS>void  </RETURNS>
MSNoSync *nosync
</FUNCTION>
<MACRO>
<NAME>MS_NOSYNC</NAME>
#define MS_NOSYNC(sync) ((MSNoSync*)(sync))
</MACRO>
<MACRO>
<NAME>MS_NOSYNC_CLASS</NAME>
#define MS_NOSYNC_CLASS(klass) ((MSNoSyncClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_nosync_new</NAME>
<RETURNS>MSSync  *</RETURNS>

</FUNCTION>
<MACRO>
<NAME>MSOSS_MAX_DEVICES</NAME>
#define MSOSS_MAX_DEVICES 4
</MACRO>
<STRUCT>
<NAME>SndCard</NAME>
struct SndCard
{
	gchar *dev_name;            /* /dev/dsp0 for example */
	gchar *mixdev_name;         /* /dev/mixer0 for example */
	gchar *card_name;          /* SB16 PCI for example */
	gint fd;   /* the file descriptor of the open soundcard, 0 if not open*/
	guint16 blocksize;
	gint16 rate;
	gchar stereo;
	gchar bits;
};
</STRUCT>
<STRUCT>
<NAME>SndCard</NAME>
</STRUCT>
<STRUCT>
<NAME>MSOss</NAME>
struct MSOss
{
	SndCard card[MSOSS_MAX_DEVICES];
	gint wcards; /* working cards */
	gint defcard;	/* the default card to be used */
};
</STRUCT>
<STRUCT>
<NAME>MSOss</NAME>
</STRUCT>
<MACRO>
<NAME>MS_OSS</NAME>
#define MS_OSS(obj)  ( (MSOss*)(obj) )
</MACRO>
<FUNCTION>
<NAME>ms_oss_init</NAME>
<RETURNS>void  </RETURNS>
MSOss *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_set_default_card</NAME>
<RETURNS>void  </RETURNS>
MSOss *obj, int index
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_opendev</NAME>
<RETURNS>int  </RETURNS>
MSOss *obj,int devid, int bits, int stereo, int rate, int blocksize
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_closedev</NAME>
<RETURNS>void  </RETURNS>
MSOss *obj,int devid
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_set_dev_name</NAME>
<RETURNS>void  </RETURNS>
MSOss *klass, int devid, char *path
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_set_mixdev_name</NAME>
<RETURNS>void  </RETURNS>
MSOss *klass,int devid, char *path
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_set_plevel</NAME>
<RETURNS>void  </RETURNS>
MSOss *obj, gint devid, gint a
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_set_rlevel</NAME>
<RETURNS>void  </RETURNS>
MSOss *obj, gint devid, gint a
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_set_glevel</NAME>
<RETURNS>void  </RETURNS>
MSOss *obj,gint devid, gint a
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_get_glevel</NAME>
<RETURNS>gint  </RETURNS>
MSOss *obj,gint devid
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_set_source</NAME>
<RETURNS>void  </RETURNS>
MSOss *obj, gint devid, gchar source
</FUNCTION>
<MACRO>
<NAME>ms_oss_getfd</NAME>
#define ms_oss_getfd(o,devid) ((o)->card[devid].fd)
</MACRO>
<MACRO>
<NAME>ms_oss_getbsize</NAME>
#define ms_oss_getbsize(o,devid) ((o)->card[devid].blocksize)
</MACRO>
<VARIABLE>
<NAME>oss_mgr</NAME>
extern MSOss oss_mgr;
</VARIABLE>
<MACRO>
<NAME>MS_OSS_READ_MAX_INPUTS</NAME>
#define MS_OSS_READ_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_OSS_READ_DEF_GRAN</NAME>
#define MS_OSS_READ_DEF_GRAN (512) /* the default granularity*/
</MACRO>
<STRUCT>
<NAME>MSOssRead</NAME>
struct MSOssRead
{
	/* the MSOssRead derivates from MSSoundRead so the MSSoundRead object MUST be the first of the MSOssRead object
       in order to the object mechanism to work*/
	MSSoundRead filter;
	MSFifo *f_outputs[MS_OSS_READ_MAX_INPUTS];
	MSSync *sync;
	SndCard *sndcard;
	gint freq;
	gint devid;  /* the sound device id it depends on*/
	gint bsize;
	gint flags;
#define START_REQUESTED 1
#define STOP_REQUESTED  2
};
</STRUCT>
<STRUCT>
<NAME>MSOssRead</NAME>
</STRUCT>
<STRUCT>
<NAME>MSOssReadClass</NAME>
struct MSOssReadClass
{
	/* the MSOssRead derivates from MSSoundRead, so the MSSoundRead class MUST be the first of the MSOssRead class
       in order to the class mechanism to work*/
	MSSoundReadClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSOssReadClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_OSS_READ</NAME>
#define MS_OSS_READ(filter) ((MSOssRead*)(filter))
</MACRO>
<MACRO>
<NAME>MS_OSS_READ_CLASS</NAME>
#define MS_OSS_READ_CLASS(klass) ((MSOssReadClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_oss_read_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_set_device</NAME>
<RETURNS>gint  </RETURNS>
MSOssRead *w,gint devid
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_start</NAME>
<RETURNS>void  </RETURNS>
MSOssRead *w
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_stop</NAME>
<RETURNS>void  </RETURNS>
MSOssRead *w
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_set_level</NAME>
<RETURNS>void  </RETURNS>
MSOssRead *w,gint a
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_init</NAME>
<RETURNS>void  </RETURNS>
MSOssRead *r
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_class_init</NAME>
<RETURNS>void  </RETURNS>
MSOssReadClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSOssRead *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_process</NAME>
<RETURNS>void  </RETURNS>
MSOssRead *f
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_read_setup</NAME>
<RETURNS>void  </RETURNS>
MSOssRead *f, MSSync *sync
</FUNCTION>
<MACRO>
<NAME>MS_OSS_WRITE_MAX_INPUTS</NAME>
#define MS_OSS_WRITE_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_OSS_WRITE_DEF_GRAN</NAME>
#define MS_OSS_WRITE_DEF_GRAN (512) /* the default granularity*/
</MACRO>
<STRUCT>
<NAME>MSOssWrite</NAME>
struct MSOssWrite
{
	/* the MSOssWrite derivates from MSSoundWrite, so the MSSoundWrite object MUST be the first of the MSOssWrite object
       in order to the object mechanism to work*/
	MSSoundWrite filter;
	MSFifo *f_inputs[MS_OSS_WRITE_MAX_INPUTS];
	gint devid;  /* the sound device id it depends on*/
	SndCard *sndcard;
	gint bsize;
	gint freq;
};
</STRUCT>
<STRUCT>
<NAME>MSOssWrite</NAME>
</STRUCT>
<STRUCT>
<NAME>MSOssWriteClass</NAME>
struct MSOssWriteClass
{
	/* the MSOssWrite derivates from MSSoundWrite, so the MSSoundWrite class MUST be the first of the MSOssWrite class
       in order to the class mechanism to work*/
	MSSoundWriteClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSOssWriteClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_OSS_WRITE</NAME>
#define MS_OSS_WRITE(filter) ((MSOssWrite*)(filter))
</MACRO>
<MACRO>
<NAME>MS_OSS_WRITE_CLASS</NAME>
#define MS_OSS_WRITE_CLASS(klass) ((MSOssWriteClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_oss_write_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_set_device</NAME>
<RETURNS>gint  </RETURNS>
MSOssWrite *w,gint devid
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_start</NAME>
<RETURNS>void  </RETURNS>
MSOssWrite *w
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_stop</NAME>
<RETURNS>void  </RETURNS>
MSOssWrite *w
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_set_level</NAME>
<RETURNS>void  </RETURNS>
MSOssWrite *w, gint level
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_init</NAME>
<RETURNS>void  </RETURNS>
MSOssWrite *r
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_setup</NAME>
<RETURNS>void  </RETURNS>
MSOssWrite *r
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_class_init</NAME>
<RETURNS>void  </RETURNS>
MSOssWriteClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSOssWrite *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_oss_write_process</NAME>
<RETURNS>void  </RETURNS>
MSOssWrite *f
</FUNCTION>
<MACRO>
<NAME>MS_QDISPATCHER_MAX_INPUTS</NAME>
#define MS_QDISPATCHER_MAX_INPUTS  1
</MACRO>
<MACRO>
<NAME>MS_QDISPATCHER_MAX_OUTPUTS</NAME>
#define MS_QDISPATCHER_MAX_OUTPUTS 5 
</MACRO>
<MACRO>
<NAME>MS_QDISPATCHER</NAME>
#define MS_QDISPATCHER(filter) ((MSQdispatcher*)(filter))
</MACRO>
<MACRO>
<NAME>MS_QDISPATCHER_CLASS</NAME>
#define MS_QDISPATCHER_CLASS(klass) ((MSQdispatcherClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_qdispatcher_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_qdispatcher_init</NAME>
<RETURNS>void  </RETURNS>
MSQdispatcher *r
</FUNCTION>
<FUNCTION>
<NAME>ms_qdispatcher_class_init</NAME>
<RETURNS>void  </RETURNS>
MSQdispatcherClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_qdispatcher_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSQdispatcher *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_qdispatcher_process</NAME>
<RETURNS>void  </RETURNS>
MSQdispatcher *r
</FUNCTION>
<FUNCTION>
<NAME>ms_queue_new</NAME>
<RETURNS>MSQueue  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_queue_get</NAME>
<RETURNS>MSMessage  *</RETURNS>
MSQueue *q
</FUNCTION>
<FUNCTION>
<NAME>ms_queue_put</NAME>
<RETURNS>void  </RETURNS>
MSQueue *q, MSMessage *m
</FUNCTION>
<MACRO>
<NAME>ms_queue_can_get</NAME>
#define ms_queue_can_get(q) ( (q)->size!=0 )
</MACRO>
<MACRO>
<NAME>ms_queue_destroy</NAME>
#define ms_queue_destroy(q) g_free(q)
</MACRO>
<MACRO>
<NAME>MSREAD_MAX_OUTPUTS</NAME>
#define MSREAD_MAX_OUTPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MSREAD_DEF_GRAN</NAME>
#define MSREAD_DEF_GRAN 512 /* the default granularity*/
</MACRO>
<ENUM>
<NAME>MSReadState</NAME>
typedef enum{
	MS_READ_STATE_STARTED,
	MS_READ_STATE_STOPPED,
	MS_READ_STATE_EOF
}MSReadState;
</ENUM>
<MACRO>
<NAME>MS_READ</NAME>
#define MS_READ(filter) ((MSRead*)(filter))
</MACRO>
<MACRO>
<NAME>MS_READ_CLASS</NAME>
#define MS_READ_CLASS(klass) ((MSReadClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_read_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
char *name
</FUNCTION>
<MACRO>
<NAME>ms_read_set_bufsize</NAME>
#define ms_read_set_bufsize(filter,sz) (filter)->gran=(sz)
</MACRO>
<FUNCTION>
<NAME>ms_read_init</NAME>
<RETURNS>void  </RETURNS>
MSRead *r
</FUNCTION>
<FUNCTION>
<NAME>ms_read_class_init</NAME>
<RETURNS>void  </RETURNS>
MSReadClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_read_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSRead *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_read_process</NAME>
<RETURNS>void  </RETURNS>
MSRead *r
</FUNCTION>
<FUNCTION>
<NAME>ms_read_setup</NAME>
<RETURNS>void  </RETURNS>
MSRead *r, MSSync *sync
</FUNCTION>
<ENUM>
<NAME>MSReadEvent</NAME>
typedef enum{
	MS_READ_EVENT_EOF	/* end of file */
} MSReadEvent;
</ENUM>
<MACRO>
<NAME>MS_RING_PLAYER_MAX_OUTPUTS</NAME>
#define MS_RING_PLAYER_MAX_OUTPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MS_RING_PLAYER_DEF_GRAN</NAME>
#define MS_RING_PLAYER_DEF_GRAN 8192 /* the default granularity*/
</MACRO>
<STRUCT>
<NAME>MSRingPlayer</NAME>
struct MSRingPlayer
{
    /* the MSRingPlayer derivates from MSFilter, so the MSFilter object MUST be the first of the MSRingPlayer object
       in order to the object mechanism to work*/
    MSFilter filter;
    MSFifo *foutputs[MS_RING_PLAYER_MAX_OUTPUTS];
    MSQueue *qoutputs[MS_RING_PLAYER_MAX_OUTPUTS];\
	MSSync *sync;
    gint fd;  /* the file descriptor of the file being read*/
    gint space; /*space in samples between each ring */
    gint current_pos;
	gint need_swap;
};
</STRUCT>
<STRUCT>
<NAME>MSRingPlayer</NAME>
</STRUCT>
<STRUCT>
<NAME>MSRingPlayerClass</NAME>
struct MSRingPlayerClass
{
	/* the MSRingPlayer derivates from MSFilter, so the MSFilter class MUST be the first of the MSRingPlayer class
       in order to the class mechanism to work*/
	MSFilterClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSRingPlayerClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_RING_PLAYER</NAME>
#define MS_RING_PLAYER(filter) ((MSRingPlayer*)(filter))
</MACRO>
<MACRO>
<NAME>MS_RING_PLAYER_CLASS</NAME>
#define MS_RING_PLAYER_CLASS(klass) ((MSRingPlayerClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_ring_player_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
char *name, gint seconds
</FUNCTION>
<FUNCTION>
<NAME>ms_ring_player_init</NAME>
<RETURNS>void  </RETURNS>
MSRingPlayer *r
</FUNCTION>
<FUNCTION>
<NAME>ms_ring_player_class_init</NAME>
<RETURNS>void  </RETURNS>
MSRingPlayerClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_ring_player_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSRingPlayer *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_ring_player_process</NAME>
<RETURNS>void  </RETURNS>
MSRingPlayer *r
</FUNCTION>
<MACRO>
<NAME>ms_ring_player_set_bufsize</NAME>
#define ms_ring_player_set_bufsize(filter,sz) (filter)->gran=(sz)
</MACRO>
<FUNCTION>
<NAME>ms_ring_player_setup</NAME>
<RETURNS>void  </RETURNS>
MSRingPlayer *r,MSSync *sync
</FUNCTION>
<MACRO>
<NAME>MSRTPRECV_MAX_OUTPUTS</NAME>
#define MSRTPRECV_MAX_OUTPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MSRTPRECV_DEF_GRAN</NAME>
#define MSRTPRECV_DEF_GRAN 4096 /* the default granularity*/
</MACRO>
<STRUCT>
<NAME>MSRtpRecv</NAME>
struct MSRtpRecv
{
    /* the MSCopy derivates from MSFilter, so the MSFilter object MUST be the first of the MSCopy object
       in order to the object mechanism to work*/
    MSFilter filter;
    MSFifo *f_outputs[MSRTPRECV_MAX_OUTPUTS];
	MSQueue *q_outputs[MSRTPRECV_MAX_OUTPUTS];
	MSSync *sync;
	RtpSession *rtpsession;
	guint32 prev_ts;
	gint stream_started;
};
</STRUCT>
<STRUCT>
<NAME>MSRtpRecv</NAME>
</STRUCT>
<STRUCT>
<NAME>MSRtpRecvClass</NAME>
struct MSRtpRecvClass
{
	/* the MSCopy derivates from MSFilter, so the MSFilter class MUST be the first of the MSCopy class
       in order to the class mechanism to work*/
	MSFilterClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSRtpRecvClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_RTP_RECV</NAME>
#define MS_RTP_RECV(filter) ((MSRtpRecv*)(filter))
</MACRO>
<MACRO>
<NAME>MS_RTP_RECV_CLASS</NAME>
#define MS_RTP_RECV_CLASS(klass) ((MSRtpRecvClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_rtp_recv_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_recv_set_session</NAME>
<RETURNS>RtpSession  *</RETURNS>
MSRtpRecv *obj,RtpSession *session
</FUNCTION>
<MACRO>
<NAME>ms_rtp_recv_unset_session</NAME>
#define ms_rtp_recv_unset_session(obj) (ms_rtp_recv_set_session((obj),NULL))
</MACRO>
<MACRO>
<NAME>ms_rtp_recv_get_session</NAME>
#define ms_rtp_recv_get_session(obj) ((obj)->rtpsession)
</MACRO>
<FUNCTION>
<NAME>ms_rtp_recv_init</NAME>
<RETURNS>void  </RETURNS>
MSRtpRecv *r
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_recv_class_init</NAME>
<RETURNS>void  </RETURNS>
MSRtpRecvClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_recv_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSRtpRecv *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_recv_process</NAME>
<RETURNS>void  </RETURNS>
MSRtpRecv *r
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_recv_setup</NAME>
<RETURNS>void  </RETURNS>
MSRtpRecv *r,MSSync *sync
</FUNCTION>
<MACRO>
<NAME>MSRTPSEND_MAX_INPUTS</NAME>
#define MSRTPSEND_MAX_INPUTS  1 /* max input per filter*/
</MACRO>
<MACRO>
<NAME>MSRTPSEND_DEF_GRAN</NAME>
#define MSRTPSEND_DEF_GRAN  4096/* the default granularity*/
</MACRO>
<STRUCT>
<NAME>MSRtpSend</NAME>
struct MSRtpSend
{
    /* the MSCopy derivates from MSFilter, so the MSFilter object MUST be the first of the MSCopy object
       in order to the object mechanism to work*/
    MSFilter filter;
    MSFifo *f_inputs[MSRTPSEND_MAX_INPUTS];
	MSQueue *q_inputs[MSRTPSEND_MAX_INPUTS];
	MSSync *sync;
	RtpSession *rtpsession;
	guint32 ts;
	guint32 ts_inc;	/* the timestamp increment */
	gint packet_size;
	guint flags;
        guint delay; /* number of _proccess call which must be skipped */
#define RTPSEND_CONFIGURED (1)
};
</STRUCT>
<STRUCT>
<NAME>MSRtpSend</NAME>
</STRUCT>
<STRUCT>
<NAME>MSRtpSendClass</NAME>
struct MSRtpSendClass
{
	/* the MSRtpSend derivates from MSFilter, so the MSFilter class MUST be the first of the MSCopy class
       in order to the class mechanism to work*/
	MSFilterClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSRtpSendClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_RTP_SEND</NAME>
#define MS_RTP_SEND(filter) ((MSRtpSend*)(filter))
</MACRO>
<MACRO>
<NAME>MS_RTP_SEND_CLASS</NAME>
#define MS_RTP_SEND_CLASS(klass) ((MSRtpSendClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_rtp_send_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_send_set_session</NAME>
<RETURNS>RtpSession  *</RETURNS>
MSRtpSend *obj,RtpSession *session
</FUNCTION>
<MACRO>
<NAME>ms_rtp_send_unset_session</NAME>
#define ms_rtp_send_unset_session(obj) (ms_rtp_send_set_session((obj),NULL))
</MACRO>
<MACRO>
<NAME>ms_rtp_send_get_session</NAME>
#define ms_rtp_send_get_session(obj) ((obj)->rtpsession)
</MACRO>
<FUNCTION>
<NAME>ms_rtp_send_set_timing</NAME>
<RETURNS>void  </RETURNS>
MSRtpSend *r, guint32 ts_inc, gint payload_size
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_send_dtmf</NAME>
<RETURNS>gint  </RETURNS>
MSRtpSend *r, gchar dtmf
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_send_init</NAME>
<RETURNS>void  </RETURNS>
MSRtpSend *r
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_send_class_init</NAME>
<RETURNS>void  </RETURNS>
MSRtpSendClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_send_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSRtpSend *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_send_process</NAME>
<RETURNS>void  </RETURNS>
MSRtpSend *r
</FUNCTION>
<FUNCTION>
<NAME>ms_rtp_send_setup</NAME>
<RETURNS>void  </RETURNS>
MSRtpSend *r, MSSync *sync
</FUNCTION>
<STRUCT>
<NAME>MSSmpeg</NAME>
struct MSSmpeg
{
	MSFilter parent;
	MSQueue *input[1];
	SMPEG *handle;
	SDL_Surface *surface;
	SDL_RWops *rwops;
	int run_cond;
	int first_time;
	MSMessage *current;
	int pos;
	int end_pos;
};
</STRUCT>
<STRUCT>
<NAME>MSSmpeg</NAME>
</STRUCT>
<STRUCT>
<NAME>MSSmpegClass</NAME>
struct MSSmpegClass
{
	MSFilterClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>MSSmpegClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_SMPEG</NAME>
#define MS_SMPEG(obj)	((MSSmpeg*)(obj))
</MACRO>
<MACRO>
<NAME>MS_SMPEG_CLASS</NAME>
#define MS_SMPEG_CLASS(klass)	((MSSmpegClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_smpeg_init</NAME>
<RETURNS>void  </RETURNS>
MSSmpeg *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_smpeg_class_init</NAME>
<RETURNS>void  </RETURNS>
MSSmpegClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_smpeg_uninit</NAME>
<RETURNS>void  </RETURNS>
MSSmpeg *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_smpeg_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_smpeg_start</NAME>
<RETURNS>void  </RETURNS>
MSSmpeg *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_smpeg_stop</NAME>
<RETURNS>void  </RETURNS>
MSSmpeg *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_smpeg_destroy</NAME>
<RETURNS>void  </RETURNS>
MSSmpeg *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_smpeg_process</NAME>
<RETURNS>void  </RETURNS>
MSSmpeg *obj
</FUNCTION>
<STRUCT>
<NAME>MSSoundRead</NAME>
struct MSSoundRead
{
	/* the MSOssRead derivates from MSFilter, so the MSFilter object MUST be the first of the MSOssRead object
       in order to the object mechanism to work*/
	MSFilter filter;
};
</STRUCT>
<STRUCT>
<NAME>MSSoundRead</NAME>
</STRUCT>
<STRUCT>
<NAME>MSSoundReadClass</NAME>
struct MSSoundReadClass
{
	/* the MSOssRead derivates from MSFilter, so the MSFilter class MUST be the first of the MSOssRead class
       in order to the class mechanism to work*/
	MSFilterClass parent_class;
	gint (*set_device)(MSSoundRead *, gint devid);
	void (*start)(MSSoundRead *);
	void (*stop)(MSSoundRead*);
	void (*set_level)(MSSoundRead *, gint a);
};
</STRUCT>
<STRUCT>
<NAME>MSSoundReadClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_SOUND_READ</NAME>
#define MS_SOUND_READ(filter) ((MSSoundRead*)(filter))
</MACRO>
<MACRO>
<NAME>MS_SOUND_READ_CLASS</NAME>
#define MS_SOUND_READ_CLASS(klass) ((MSSoundReadClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>MS_SOUND_READ_CLASS</NAME>
<RETURNS>return  </RETURNS>
 MS_FILTER(r)->klass )->set_device(r,devid
</FUNCTION>
<FUNCTION>
<NAME>ms_sound_read_init</NAME>
<RETURNS>void  </RETURNS>
MSSoundRead *r
</FUNCTION>
<FUNCTION>
<NAME>ms_sound_read_class_init</NAME>
<RETURNS>void  </RETURNS>
MSSoundReadClass *klass
</FUNCTION>
<STRUCT>
<NAME>MSSoundWrite</NAME>
struct MSSoundWrite
{
	/* the MSOssWrite derivates from MSFilter, so the MSFilter object MUST be the first of the MSOssWrite object
       in order to the object mechanism to work*/
	MSFilter filter;
};
</STRUCT>
<STRUCT>
<NAME>MSSoundWrite</NAME>
</STRUCT>
<STRUCT>
<NAME>MSSoundWriteClass</NAME>
struct MSSoundWriteClass
{
	/* the MSOssWrite derivates from MSFilter, so the MSFilter class MUST be the first of the MSOssWrite class
       in order to the class mechanism to work*/
	MSFilterClass parent_class;
	gint (*set_device)(MSSoundWrite *, gint devid);
	void (*start)(MSSoundWrite *);
	void (*stop)(MSSoundWrite*);
	void (*set_level)(MSSoundWrite *, gint a);
};
</STRUCT>
<STRUCT>
<NAME>MSSoundWriteClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_SOUND_WRITE</NAME>
#define MS_SOUND_WRITE(filter) ((MSSoundWrite*)(filter))
</MACRO>
<MACRO>
<NAME>MS_SOUND_WRITE_CLASS</NAME>
#define MS_SOUND_WRITE_CLASS(klass) ((MSSoundWriteClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>MS_SOUND_WRITE_CLASS</NAME>
<RETURNS>return  </RETURNS>
 MS_FILTER(r)->klass )->set_device(r,devid
</FUNCTION>
<FUNCTION>
<NAME>ms_sound_write_init</NAME>
<RETURNS>void  </RETURNS>
MSSoundWrite *r
</FUNCTION>
<FUNCTION>
<NAME>ms_sound_write_class_init</NAME>
<RETURNS>void  </RETURNS>
MSSoundWriteClass *klass
</FUNCTION>
<STRUCT>
<NAME>MSSpeexDec</NAME>
struct MSSpeexDec
{
	MSFilter parent;
	MSQueue *inq[1]; /* speex has an input q because it can be variable bit rate */
	MSFifo *outf[1];	
	void *speex_state;
	float *outbuf;
	SpeexBits bits;
	int frequency;
	int frame_size;
	int initialized;
};
</STRUCT>
<STRUCT>
<NAME>MSSpeexDec</NAME>
</STRUCT>
<STRUCT>
<NAME>MSSpeexDecClass</NAME>
struct MSSpeexDecClass
{
	MSFilterClass parent;
};
</STRUCT>
<STRUCT>
<NAME>MSSpeexDecClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_SPEEX_DEC</NAME>
#define MS_SPEEX_DEC(o)	((MSSpeexDec*)(o))
</MACRO>
<MACRO>
<NAME>MS_SPEEX_DEC_CLASS</NAME>
#define MS_SPEEX_DEC_CLASS(o)	((MSSpeexDecClass*)(o))
</MACRO>
<FUNCTION>
<NAME>ms_speex_codec_init</NAME>
<RETURNS>void  </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_init</NAME>
<RETURNS>void  </RETURNS>
MSSpeexDec *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_init_core</NAME>
<RETURNS>void  </RETURNS>
MSSpeexDec *obj,SpeexMode *mode
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_class_init</NAME>
<RETURNS>void  </RETURNS>
MSSpeexDecClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_uninit</NAME>
<RETURNS>void  </RETURNS>
MSSpeexDec *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_uninit_core</NAME>
<RETURNS>void  </RETURNS>
MSSpeexDec *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_process</NAME>
<RETURNS>void  </RETURNS>
MSSpeexDec *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_dec_destroy</NAME>
<RETURNS>void  </RETURNS>
MSSpeexDec *obj
</FUNCTION>
<STRUCT>
<NAME>MSSpeexEnc</NAME>
struct MSSpeexEnc
{
	MSFilter parent;
	MSFifo *inf[1];
	MSQueue *outq[1];	/* speex has an output q because it can be variable bit rate */
	void *speex_state;
	float *inbuf;
	SpeexBits bits;
	int frequency;
	int bitrate;
	int initialized;
};
</STRUCT>
<STRUCT>
<NAME>MSSpeexEnc</NAME>
</STRUCT>
<STRUCT>
<NAME>MSSpeexEncClass</NAME>
struct MSSpeexEncClass
{
	MSFilterClass parent;
};
</STRUCT>
<STRUCT>
<NAME>MSSpeexEncClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_SPEEX_ENC</NAME>
#define MS_SPEEX_ENC(o)	((MSSpeexEnc*)(o))
</MACRO>
<MACRO>
<NAME>MS_SPEEX_ENC_CLASS</NAME>
#define MS_SPEEX_ENC_CLASS(o)	((MSSpeexEncClass*)(o))
</MACRO>
<FUNCTION>
<NAME>ms_speex_enc_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_speex_enc_init_core</NAME>
<RETURNS>void  </RETURNS>
MSSpeexEnc *obj,SpeexMode *mode, gint quality
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_enc_uninit_core</NAME>
<RETURNS>void  </RETURNS>
MSSpeexEnc *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_enc_init</NAME>
<RETURNS>void  </RETURNS>
MSSpeexEnc *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_enc_class_init</NAME>
<RETURNS>void  </RETURNS>
MSSpeexEncClass *klass,SpeexMode *mode
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_enc_process</NAME>
<RETURNS>void  </RETURNS>
MSSpeexEnc *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_speex_enc_destroy</NAME>
<RETURNS>void  </RETURNS>
MSSpeexEnc *obj
</FUNCTION>
<STRUCT>
<NAME>MSSync</NAME>
struct MSSync
{
	struct _MSSyncClass *klass;
	GMutex *lock;
	MSFilter **attached_filters; /* pointer to a table of pointer of filters*/
	GList *execution_list;     /* the list of filters to be executed. This is filled with compilation */
	gint filters;   /*number of filters attached to the sync */
	gint run;       /* flag to indicate whether the sync must be run or not */
	GThread * thread;   /* the thread ressource if this sync is run by a thread*/
	GCond *thread_cond;
	GCond *stop_cond;
	guint32 flags;
#define MS_SYNC_NEED_UPDATE (0x0001)  /* a modification has occured in the processing chains
							attached to this sync; so the execution list has to be updated */
	guint samples_per_tick; /* number of bytes produced by sources of the processing chains*/
	guint32 ticks;
	guint32 time;	/* a time since the start of the sync expressed in milisec*/
        guint32 mute;   /* If this is set to mute then throw away any outgoing packets */
};
</STRUCT>
<STRUCT>
<NAME>MSSync</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>MSSyncDestroyFunc</NAME>
<RETURNS>void </RETURNS>
MSSync*
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>MSSyncSyncFunc</NAME>
<RETURNS>void </RETURNS>
MSSync*
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>MSSyncAttachFunc</NAME>
<RETURNS>int </RETURNS>
MSSync*,MSFilter*
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>MSSyncDetachFunc</NAME>
<RETURNS>int </RETURNS>
MSSync*,MSFilter*
</USER_FUNCTION>
<FUNCTION>
<NAME>ms_sync_init</NAME>
<RETURNS>void  </RETURNS>
MSSync *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_sync_class_init</NAME>
<RETURNS>void  </RETURNS>
MSSyncClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_sync_attach_generic</NAME>
<RETURNS>int  </RETURNS>
MSSync *sync,MSFilter *f
</FUNCTION>
<FUNCTION>
<NAME>ms_sync_detach_generic</NAME>
<RETURNS>int  </RETURNS>
MSSync *sync,MSFilter *f
</FUNCTION>
<MACRO>
<NAME>MS_SYNC</NAME>
#define MS_SYNC(sync) ((MSSync*)(sync))
</MACRO>
<MACRO>
<NAME>MS_SYNC_CLASS</NAME>
#define MS_SYNC_CLASS(klass) ((MSSyncClass*)(klass))
</MACRO>
<MACRO>
<NAME>ms_sync_synchronize</NAME>
#define ms_sync_synchronize(_sync) \
do       \
{         \
	MSSync *__sync=_sync; \
	__sync->ticks++;       \
	((__sync)->klass->synchronize((__sync))); \
}while(0)
</MACRO>
<FUNCTION>
<NAME>ms_sync_setup</NAME>
<RETURNS>void  </RETURNS>
MSSync *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_sync_unsetup</NAME>
<RETURNS>void  </RETURNS>
MSSync *sync
</FUNCTION>
<MACRO>
<NAME>ms_sync_update</NAME>
#define ms_sync_update(sync) (sync)->flags|=MS_SYNC_NEED_UPDATE
</MACRO>
<MACRO>
<NAME>ms_sync_get_samples_per_tick</NAME>
#define ms_sync_get_samples_per_tick(sync) ((sync)->samples_per_tick)
</MACRO>
<FUNCTION>
<NAME>ms_sync_set_samples_per_tick</NAME>
<RETURNS>void  </RETURNS>
MSSync *sync,gint size
</FUNCTION>
<MACRO>
<NAME>ms_sync_get_tick_count</NAME>
#define ms_sync_get_tick_count(sync)  ((sync)->ticks)
</MACRO>
<MACRO>
<NAME>ms_sync_suspend</NAME>
#define ms_sync_suspend(sync) g_cond_wait((sync)->thread_cond,(sync)->lock)
</MACRO>
<MACRO>
<NAME>ms_sync_lock</NAME>
#define ms_sync_lock(sync) g_mutex_lock((sync)->lock)
</MACRO>
<MACRO>
<NAME>ms_sync_unlock</NAME>
#define ms_sync_unlock(sync) g_mutex_unlock((sync)->lock)
</MACRO>
<MACRO>
<NAME>ms_sync_trylock</NAME>
#define ms_sync_trylock(sync) g_mutex_trylock((sync)->lock)
</MACRO>
<FUNCTION>
<NAME>ms_sync_attach</NAME>
<RETURNS>int  </RETURNS>
MSSync *sync,MSFilter *f
</FUNCTION>
<FUNCTION>
<NAME>ms_sync_detach</NAME>
<RETURNS>int  </RETURNS>
MSSync *sync,MSFilter *f
</FUNCTION>
<FUNCTION>
<NAME>ms_sync_uninit</NAME>
<RETURNS>int  </RETURNS>
MSSync *sync
</FUNCTION>
<MACRO>
<NAME>ms_sync_destroy</NAME>
#define ms_sync_destroy(sync)     (sync)->klass->destroy((sync))
</MACRO>
<MACRO>
<NAME>MSTIMER_MAX_FILTERS</NAME>
#define MSTIMER_MAX_FILTERS 10
</MACRO>
<MACRO>
<NAME>MS_TIMER_RUNNING</NAME>
#define MS_TIMER_RUNNING 1
</MACRO>
<MACRO>
<NAME>MS_TIMER_STOPPED</NAME>
#define MS_TIMER_STOPPED 0
</MACRO>
<FUNCTION>
<NAME>ms_timer_init</NAME>
<RETURNS>void  </RETURNS>
MSTimer *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_timer_class_init</NAME>
<RETURNS>void  </RETURNS>
MSTimerClass *sync
</FUNCTION>
<FUNCTION>
<NAME>ms_timer_destroy</NAME>
<RETURNS>void  </RETURNS>
MSTimer *timer
</FUNCTION>
<FUNCTION>
<NAME>ms_timer_synchronize</NAME>
<RETURNS>void  </RETURNS>
MSTimer *timer
</FUNCTION>
<FUNCTION>
<NAME>ms_timer_set_interval</NAME>
<RETURNS>void  </RETURNS>
MSTimer *timer, gint milisec
</FUNCTION>
<MACRO>
<NAME>MS_TIMER</NAME>
#define MS_TIMER(sync) ((MSTimer*)(sync))
</MACRO>
<MACRO>
<NAME>MS_TIMER_CLASS</NAME>
#define MS_TIMER_CLASS(klass) ((MSTimerClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_timer_new</NAME>
<RETURNS>MSSync  *</RETURNS>

</FUNCTION>
<MACRO>
<NAME>ENODATA</NAME>
#define ENODATA EWOULDBLOCK	
</MACRO>
<MACRO>
<NAME>ms_trace</NAME>
#define ms_trace g_message
</MACRO>
<MACRO>
<NAME>ms_trace</NAME>
#define ms_trace(...)
</MACRO>
<MACRO>
<NAME>ms_warning</NAME>
#define ms_warning g_warning
</MACRO>
<MACRO>
<NAME>ms_error</NAME>
#define ms_error g_error
</MACRO>
<STRUCT>
<NAME>MSV4l</NAME>
struct MSV4l
{
	MSVideoSource parent;
	int fd;
	char *device;
	struct video_capability cap;
	struct video_channel channel;
	struct video_window win;
	struct video_picture pict;
	struct video_mmap vmap;
	struct video_mbuf vmbuf;
	gint bsize;
	MSBuffer bufwrap;  /* the buffer used in read */
	char *buffer;  /* the main receiving buffer for mmap and read */
	gint use_mmap;
	gint frame;
	guint read_frame;
	guint query_frame;
	MSBuffer img[VIDEO_MAX_FRAME];	/* the buffer used for mmaps */
};
</STRUCT>
<STRUCT>
<NAME>MSV4l</NAME>
</STRUCT>
<STRUCT>
<NAME>MSV4lClass</NAME>
struct MSV4lClass
{
	MSVideoSourceClass parent_class;
	
};
</STRUCT>
<STRUCT>
<NAME>MSV4lClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_V4L</NAME>
#define MS_V4L(v)		((MSV4l*)(v))
</MACRO>
<MACRO>
<NAME>MS_V4L_CLASS</NAME>
#define MS_V4L_CLASS(k)		((MSV4lClass*)(k))
</MACRO>
<FUNCTION>
<NAME>ms_v4l_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_start</NAME>
<RETURNS>void  </RETURNS>
MSV4l *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_stop</NAME>
<RETURNS>void  </RETURNS>
MSV4l *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_set_device</NAME>
<RETURNS>int  </RETURNS>
MSV4l *f, gchar *device
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_get_width</NAME>
<RETURNS>gint  </RETURNS>
MSV4l *v4l
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_get_height</NAME>
<RETURNS>gint  </RETURNS>
MSV4l *v4l
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_init</NAME>
<RETURNS>void  </RETURNS>
MSV4l *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_class_init</NAME>
<RETURNS>void  </RETURNS>
MSV4lClass *klass
</FUNCTION>
<FUNCTION>
<NAME>v4l_configure</NAME>
<RETURNS>int  </RETURNS>
MSV4l *f
</FUNCTION>
<FUNCTION>
<NAME>v4l_process</NAME>
<RETURNS>void  </RETURNS>
MSV4l *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_uninit</NAME>
<RETURNS>void  </RETURNS>
MSV4l *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_v4l_destroy</NAME>
<RETURNS>void  </RETURNS>
MSV4l *obj
</FUNCTION>
<VARIABLE>
<NAME>v4l_info</NAME>
extern MSFilterInfo v4l_info;
</VARIABLE>
<STRUCT>
<NAME>MSVideoOutput</NAME>
struct MSVideoOutput
{
	MSFilter parent;
	MSQueue *input[1];
	GdkWindow *window;
	GdkGC *gc;
	GdkImage *image;
	gint width,height;
	gint bufsize;
	gchar *palette;
};
</STRUCT>
<STRUCT>
<NAME>MSVideoOutput</NAME>
</STRUCT>
<STRUCT>
<NAME>MSVideoOutputClass</NAME>
struct MSVideoOutputClass
{
	MSFilterClass parent_class;
	GdkVisual *visual;
	GdkColormap *colormap;
};
</STRUCT>
<STRUCT>
<NAME>MSVideoOutputClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_VIDEO_OUTPUT</NAME>
#define MS_VIDEO_OUTPUT(obj)	((MSVideoOutput*)(obj))
</MACRO>
<MACRO>
<NAME>MS_VIDEO_OUTPUT_CLASS</NAME>
#define MS_VIDEO_OUTPUT_CLASS(klass)	((MSVideoOutputClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_video_output_init</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_class_init</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutputClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_uninit</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_set_size</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj,gint width, gint height
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_start</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_stop</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_set_title</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj,gchar *title
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_destroy</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_video_output_process</NAME>
<RETURNS>void  </RETURNS>
MSVideoOutput *obj
</FUNCTION>
<MACRO>
<NAME>MSVIDEOSOURCE_MAX_OUTPUTS</NAME>
#define MSVIDEOSOURCE_MAX_OUTPUTS  1 /* max output per filter*/
</MACRO>
<FUNCTION>
<NAME>ms_video_source_set_device</NAME>
<RETURNS>int  </RETURNS>
MSVideoSource *f, gchar *device
</FUNCTION>
<FUNCTION>
<NAME>ms_video_source_get_device_name</NAME>
<RETURNS>gchar *</RETURNS>
MSVideoSource *f
</FUNCTION>
<FUNCTION>
<NAME>ms_video_source_start</NAME>
<RETURNS>void  </RETURNS>
MSVideoSource *f
</FUNCTION>
<FUNCTION>
<NAME>ms_video_source_stop</NAME>
<RETURNS>void  </RETURNS>
MSVideoSource *f
</FUNCTION>
<MACRO>
<NAME>MS_VIDEO_SOURCE</NAME>
#define MS_VIDEO_SOURCE(obj)		((MSVideoSource*)(obj))
</MACRO>
<MACRO>
<NAME>MS_VIDEO_SOURCE_CLASS</NAME>
#define MS_VIDEO_SOURCE_CLASS(klass)		((MSVideoSourceClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_video_source_init</NAME>
<RETURNS>void  </RETURNS>
MSVideoSource *f
</FUNCTION>
<FUNCTION>
<NAME>ms_video_source_class_init</NAME>
<RETURNS>void  </RETURNS>
MSVideoSourceClass *klass
</FUNCTION>
<MACRO>
<NAME>MSWRITE_MAX_INPUTS</NAME>
#define MSWRITE_MAX_INPUTS  1 /* max output per filter*/
</MACRO>
<MACRO>
<NAME>MSWRITE_DEF_GRAN</NAME>
#define MSWRITE_DEF_GRAN 512 /* the default granularity*/
</MACRO>
<MACRO>
<NAME>MSWRITE_MIN_GRAN</NAME>
#define MSWRITE_MIN_GRAN 64
</MACRO>
<MACRO>
<NAME>MS_WRITE</NAME>
#define MS_WRITE(filter) ((MSWrite*)(filter))
</MACRO>
<MACRO>
<NAME>MS_WRITE_CLASS</NAME>
#define MS_WRITE_CLASS(klass) ((MSWriteClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_write_new</NAME>
<RETURNS>MSFilter  *</RETURNS>
char *name
</FUNCTION>
<FUNCTION>
<NAME>ms_write_init</NAME>
<RETURNS>void  </RETURNS>
MSWrite *r
</FUNCTION>
<FUNCTION>
<NAME>ms_write_class_init</NAME>
<RETURNS>void  </RETURNS>
MSWriteClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_write_destroy</NAME>
<RETURNS>void  </RETURNS>
 MSWrite *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_write_process</NAME>
<RETURNS>void  </RETURNS>
MSWrite *r
</FUNCTION>
<STRUCT>
<NAME>MSXine</NAME>
struct MSXine
{
	MSFilter parent;
	MSQueue *input[1];
	x11_visual_t vis;
	vo_driver_t *vo_driver;
	xine_t *engine;
};
</STRUCT>
<STRUCT>
<NAME>MSXine</NAME>
</STRUCT>
<STRUCT>
<NAME>MSXineClass</NAME>
struct MSXineClass
{
	MSFilterClass parent_class;
	config_values_t *config;
	char **video_plugins;
	
};
</STRUCT>
<STRUCT>
<NAME>MSXineClass</NAME>
</STRUCT>
<MACRO>
<NAME>MS_XINE</NAME>
#define MS_XINE(obj)	((MSXine*)(obj))
</MACRO>
<MACRO>
<NAME>MS_XINE_CLASS</NAME>
#define MS_XINE_CLASS(klass)	((MSXineClass*)(klass))
</MACRO>
<FUNCTION>
<NAME>ms_xine_init</NAME>
<RETURNS>void  </RETURNS>
MSXine *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_xine_class_init</NAME>
<RETURNS>void  </RETURNS>
MSXineClass *klass
</FUNCTION>
<FUNCTION>
<NAME>ms_xine_uninit</NAME>
<RETURNS>void  </RETURNS>
MSXine *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_xine_new</NAME>
<RETURNS>MSFilter  *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>ms_xine_start</NAME>
<RETURNS>void  </RETURNS>
MSXine *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_xine_stop</NAME>
<RETURNS>void  </RETURNS>
MSXine *obj
</FUNCTION>
<FUNCTION>
<NAME>ms_xine_destroy</NAME>
<RETURNS>void  </RETURNS>
MSXine *obj
</FUNCTION>
<USER_FUNCTION>
<NAME>SndCardOpenFunc</NAME>
<RETURNS>int </RETURNS>
struct _SndCard*,int, int, int
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardCloseFunc</NAME>
<RETURNS>void </RETURNS>
struct _SndCard*
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardIOFunc</NAME>
<RETURNS>gint </RETURNS>
struct _SndCard*,char *,int
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardDestroyFunc</NAME>
<RETURNS>void </RETURNS>
struct _SndCard*
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardPollFunc</NAME>
<RETURNS>gboolean </RETURNS>
struct _SndCard*
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardMixerGetLevelFunc</NAME>
<RETURNS>gint </RETURNS>
struct _SndCard*,gint
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardMixerSetRecSourceFunc</NAME>
<RETURNS>void </RETURNS>
struct _SndCard*,gint
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardMixerSetLevelFunc</NAME>
<RETURNS>void </RETURNS>
struct _SndCard*,gint ,gint
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SndCardCreateFilterFunc</NAME>
<RETURNS>MSFilter *</RETURNS>
struct _SndCard *
</USER_FUNCTION>
<STRUCT>
<NAME>SndCard</NAME>
struct SndCard
{
	gchar *card_name;          /* SB16 PCI for example */
	gint index;
	gint bsize;
	gint rate;
	gint stereo;
	gint bits;
	gint flags;
#define SND_CARD_FLAGS_OPENED 1
	SndCardOpenFunc _probe;
	SndCardOpenFunc _open_r;
	SndCardOpenFunc _open_w;
	SndCardPollFunc _can_read;
	SndCardIOFunc _read;
	SndCardIOFunc _write;
	SndCardCloseFunc _close_r;
	SndCardCloseFunc _close_w;
	SndCardMixerGetLevelFunc _get_level;
	SndCardMixerSetLevelFunc _set_level;
	SndCardMixerSetRecSourceFunc _set_rec_source;
	SndCardCreateFilterFunc _create_read_filter;
	SndCardCreateFilterFunc _create_write_filter;
	SndCardDestroyFunc _destroy;
};
</STRUCT>
<STRUCT>
<NAME>SndCard</NAME>
</STRUCT>
<FUNCTION>
<NAME>snd_card_init</NAME>
<RETURNS>void  </RETURNS>
SndCard *obj
</FUNCTION>
<FUNCTION>
<NAME>snd_card_uninit</NAME>
<RETURNS>void  </RETURNS>
SndCard *obj
</FUNCTION>
<FUNCTION>
<NAME>snd_card_probe</NAME>
<RETURNS>gint  </RETURNS>
SndCard *obj, int bits, int stereo, int rate
</FUNCTION>
<FUNCTION>
<NAME>snd_card_open_r</NAME>
<RETURNS>int  </RETURNS>
SndCard *obj, int bits, int stereo, int rate
</FUNCTION>
<FUNCTION>
<NAME>snd_card_open_w</NAME>
<RETURNS>int  </RETURNS>
SndCard *obj, int bits, int stereo, int rate
</FUNCTION>
<FUNCTION>
<NAME>snd_card_get_bsize</NAME>
<RETURNS>int  </RETURNS>
SndCard *obj
</FUNCTION>
<FUNCTION>
<NAME>snd_card_can_read</NAME>
<RETURNS>gboolean  </RETURNS>
SndCard *obj
</FUNCTION>
<FUNCTION>
<NAME>snd_card_read</NAME>
<RETURNS>int  </RETURNS>
SndCard *obj,char *buffer,int size
</FUNCTION>
<FUNCTION>
<NAME>snd_card_write</NAME>
<RETURNS>int  </RETURNS>
SndCard *obj,char *buffer,int size
</FUNCTION>
<FUNCTION>
<NAME>snd_card_set_rec_source</NAME>
<RETURNS>void  </RETURNS>
SndCard *obj, int source
</FUNCTION>
<FUNCTION>
<NAME>snd_card_set_level</NAME>
<RETURNS>void  </RETURNS>
SndCard *obj, int way, int level
</FUNCTION>
<FUNCTION>
<NAME>snd_card_get_level</NAME>
<RETURNS>gint  </RETURNS>
SndCard *obj,int way
</FUNCTION>
<FUNCTION>
<NAME>snd_card_get_identifier</NAME>
<RETURNS>gchar  *</RETURNS>
SndCard *obj
</FUNCTION>
<STRUCT>
<NAME>MSFilter</NAME>
struct MSFilter * snd_card_create_read_filter(SndCard *sndcard);
struct _MSFilter * snd_card_create_write_filter(SndCard *sndcard);


#define SND_CARD_LEVEL_GENERAL 1
#define SND_CARD_LEVEL_INPUT   2
#define SND_CARD_LEVEL_OUTPUT  3


int snd_card_destroy(SndCard *obj);

#define SND_CARD(obj) ((SndCard*)(obj))

/* An implementation of SndCard : the OssCard */
#define OSS_CARD_BUFFERS 3
struct _OssCard
{
	SndCard parent;
	gchar *dev_name;            /* /dev/dsp0 for example */
	gchar *mixdev_name;         /* /dev/mixer0 for example */
	gint fd;   /* the file descriptor of the open soundcard, 0 if not open*/
	gint ref;
	gchar *readbuf;
	gint readpos;
	gchar *writebuf;
	gint writepos; 
};
</STRUCT>
<STRUCT>
<NAME>OssCard</NAME>
</STRUCT>
<FUNCTION>
<NAME>oss_card_new</NAME>
<RETURNS>SndCard  *</RETURNS>
char *devname, char *mixdev_name
</FUNCTION>
<MACRO>
<NAME>MAX_SND_CARDS</NAME>
#define MAX_SND_CARDS 5
</MACRO>
<STRUCT>
<NAME>SndCardManager</NAME>
struct SndCardManager
{
	SndCard *cards[MAX_SND_CARDS];
};
</STRUCT>
<STRUCT>
<NAME>SndCardManager</NAME>
</STRUCT>
<FUNCTION>
<NAME>snd_card_manager_init</NAME>
<RETURNS>void  </RETURNS>
SndCardManager *manager
</FUNCTION>
<FUNCTION>
<NAME>snd_card_manager_get_card</NAME>
<RETURNS>SndCard  *</RETURNS>
SndCardManager *manager,int index
</FUNCTION>
<VARIABLE>
<NAME>snd_card_manager</NAME>
extern SndCardManager *snd_card_manager;
</VARIABLE>
