← Back to branch summary

~ubuntu-branches/ubuntu/vivid/linphone/vivid

« back to all changes in this revision

Viewing changes to mediastreamer2/src/msfilter.c

  • Committer: Bazaar Package Importer
  • Author(s): Samuel Mimram
  • Date: 2006-11-15 10:34:50 UTC
  • mfrom: (1.2.1 upstream) (2.1.8 feisty)
  • Revision ID: james.westby@ubuntu.com-20061115103450-qgafwcks2lkhctlj
http://bugs.debian.org/398307
* New upstream release.
* Enable video support.
* Fix mismatched #endif in mscommon.h, closes: #398307.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mediastreamer2/src/msfilter.c
 
1
/*
 
2
mediastreamer2 library - modular sound and video processing and streaming
 
3
Copyright (C) 2006  Simon MORLAT (simon.morlat@linphone.org)
 
4
 
 
5
This program is free software; you can redistribute it and/or
 
6
modify it under the terms of the GNU General Public License
 
7
as published by the Free Software Foundation; either version 2
 
8
of the License, or (at your option) any later version.
 
9
 
 
10
This program is distributed in the hope that it will be useful,
 
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
GNU General Public License for more details.
 
14
 
 
15
You should have received a copy of the GNU General Public License
 
16
along with this program; if not, write to the Free Software
 
17
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
18
*/
 
19
 
 
20
#include "mediastreamer2/msfilter.h"
 
21
#include "mediastreamer2/mscommon.h"
 
22
 
 
23
static MSList *desc_list=NULL;
 
24
 
 
25
void ms_filter_register(MSFilterDesc *desc){
 
26
        if (desc->id==MS_FILTER_NOT_SET_ID){
 
27
                ms_fatal("MSFilterId for %s not set !",desc->name);
 
28
        }
 
29
        desc_list=ms_list_append(desc_list,desc);
 
30
}
 
31
 
 
32
void ms_filter_unregister_all(){
 
33
        if (desc_list!=NULL) ms_list_free(desc_list);
 
34
}
 
35
 
 
36
bool_t ms_filter_codec_supported(const char *mime){
 
37
        if (ms_filter_get_encoder(mime)!=NULL
 
38
                && ms_filter_get_decoder(mime)!=NULL) return TRUE;
 
39
        return FALSE;
 
40
}
 
41
 
 
42
MSFilterDesc * ms_filter_get_encoder(const char *mime){
 
43
        MSList *elem;
 
44
        for (elem=desc_list;elem!=NULL;elem=ms_list_next(elem)){
 
45
                MSFilterDesc *desc=(MSFilterDesc*)elem->data;
 
46
                if (desc->category==MS_FILTER_ENCODER && 
 
47
                        strcasecmp(desc->enc_fmt,mime)==0){
 
48
                        return desc;
 
49
                }
 
50
        }
 
51
        return NULL;
 
52
}
 
53
 
 
54
MSFilterDesc * ms_filter_get_decoder(const char *mime){
 
55
        MSList *elem;
 
56
        for (elem=desc_list;elem!=NULL;elem=ms_list_next(elem)){
 
57
                MSFilterDesc *desc=(MSFilterDesc*)elem->data;
 
58
                if (desc->category==MS_FILTER_DECODER && 
 
59
                        strcasecmp(desc->enc_fmt,mime)==0){
 
60
                        return desc;
 
61
                }
 
62
        }
 
63
        return NULL;
 
64
}
 
65
 
 
66
MSFilter * ms_filter_create_encoder(const char *mime){
 
67
        MSFilterDesc *desc=ms_filter_get_encoder(mime);
 
68
        if (desc!=NULL) return ms_filter_new_from_desc(desc);
 
69
        return NULL;
 
70
}
 
71
 
 
72
MSFilter * ms_filter_create_decoder(const char *mime){
 
73
        MSFilterDesc *desc=ms_filter_get_decoder(mime);
 
74
        if (desc!=NULL) return ms_filter_new_from_desc(desc);
 
75
        return NULL;
 
76
}
 
77
 
 
78
MSFilter *ms_filter_new_from_desc(MSFilterDesc *desc){
 
79
        MSFilter *obj;
 
80
        obj=ms_new0(MSFilter,1);
 
81
        ms_mutex_init(&obj->lock,NULL);
 
82
        obj->desc=desc;
 
83
        if (desc->ninputs>0)    obj->inputs=ms_new0(MSQueue*,desc->ninputs);
 
84
        if (desc->noutputs>0)   obj->outputs=ms_new0(MSQueue*,desc->noutputs);
 
85
        if (desc->ninputs==0 && desc->noutputs==0)
 
86
                ms_fatal("A filter cannot have no inputs and outputs");
 
87
        if (obj->desc->init!=NULL)
 
88
                obj->desc->init(obj);
 
89
        return obj;
 
90
}
 
91
 
 
92
MSFilter *ms_filter_new(MSFilterId id){
 
93
        MSList *elem;
 
94
        if (id==MS_FILTER_PLUGIN_ID){
 
95
                ms_warning("cannot create plugin filters with ms_filter_new_from_id()");
 
96
                return NULL;
 
97
        }
 
98
        for (elem=desc_list;elem!=NULL;elem=ms_list_next(elem)){
 
99
                MSFilterDesc *desc=(MSFilterDesc*)elem->data;
 
100
                if (desc->id==id){
 
101
                        return ms_filter_new_from_desc(desc);
 
102
                }
 
103
        }
 
104
        ms_error("No such filter with id %i",id);
 
105
        return NULL;
 
106
}
 
107
 
 
108
MSFilterId ms_filter_get_id(MSFilter *f){
 
109
        return f->desc->id;
 
110
}
 
111
 
 
112
int ms_filter_link(MSFilter *f1, int pin1, MSFilter *f2, int pin2){
 
113
        MSQueue *q;
 
114
        ms_return_val_if_fail(pin1<f1->desc->noutputs, -1);
 
115
        ms_return_val_if_fail(pin2<f2->desc->ninputs, -1);
 
116
        ms_return_val_if_fail(f1->outputs[pin1]==NULL,-1);
 
117
        ms_return_val_if_fail(f2->inputs[pin2]==NULL,-1);
 
118
        q=ms_queue_new(f1,pin1,f2,pin2);
 
119
        f1->outputs[pin1]=q;
 
120
        f2->inputs[pin2]=q;
 
121
        ms_message("ms_filter_link: %s:%p,%i-->%s:%p,%i",f1->desc->name,f1,pin1,f2->desc->name,f2,pin2);
 
122
        return 0;
 
123
}
 
124
 
 
125
int ms_filter_unlink(MSFilter *f1, int pin1, MSFilter *f2, int pin2){
 
126
        MSQueue *q;
 
127
        ms_return_val_if_fail(pin1<f1->desc->noutputs, -1);
 
128
        ms_return_val_if_fail(pin2<f2->desc->ninputs, -1);
 
129
        ms_return_val_if_fail(f1->outputs[pin1]!=NULL,-1);
 
130
        ms_return_val_if_fail(f2->inputs[pin2]!=NULL,-1);
 
131
        ms_return_val_if_fail(f1->outputs[pin1]==f2->inputs[pin2],-1);
 
132
        q=f1->outputs[pin1];
 
133
        f1->outputs[pin1]=f2->inputs[pin2]=0;
 
134
        ms_queue_destroy(q);
 
135
        ms_message("ms_filter_unlink: %s:%p,%i-->%s:%p,%i",f1->desc->name,f1,pin1,f2->desc->name,f2,pin2);
 
136
        return 0;
 
137
}
 
138
 
 
139
#define MS_FILTER_METHOD_GET_FID(id)    (((id)>>16) & 0xFFFF)
 
140
 
 
141
int ms_filter_call_method(MSFilter *f, unsigned int id, void *arg){
 
142
        MSFilterMethod *methods=f->desc->methods;
 
143
        int i;
 
144
        unsigned int magic=MS_FILTER_METHOD_GET_FID(id);
 
145
        if (magic!=MS_FILTER_BASE_ID && magic!=f->desc->id) {
 
146
                ms_fatal("Bad method definition in filter %s",f->desc->name);
 
147
                return -1;
 
148
        }
 
149
        for(i=0;methods!=NULL && methods[i].method!=NULL; i++){
 
150
                unsigned int mm=MS_FILTER_METHOD_GET_FID(methods[i].id);
 
151
                if (mm!=f->desc->id && mm!=MS_FILTER_BASE_ID) {
 
152
                        ms_fatal("MSFilter method mismatch: bad call.");
 
153
                        return -1;
 
154
                }
 
155
                if (methods[i].id==id){
 
156
                        return methods[i].method(f,arg);
 
157
                }
 
158
        }
 
159
        if (magic!=MS_FILTER_BASE_ID) ms_error("no such method on filter %s",f->desc->name);
 
160
        return -1;
 
161
}
 
162
 
 
163
int ms_filter_call_method_noarg(MSFilter *f, unsigned int id){
 
164
        return ms_filter_call_method(f,id,NULL);
 
165
}
 
166
 
 
167
void ms_filter_set_notify_callback(MSFilter *f, MSFilterNotifyFunc fn, void *ud){
 
168
        f->notify=fn;
 
169
        f->notify_ud=ud;
 
170
}
 
171
 
 
172
void ms_filter_destroy(MSFilter *f){
 
173
        if (f->desc->uninit!=NULL)
 
174
                f->desc->uninit(f);
 
175
        if (f->inputs!=NULL)    ms_free(f->inputs);
 
176
        if (f->outputs!=NULL)   ms_free(f->outputs);
 
177
        ms_mutex_destroy(&f->lock);
 
178
        ms_free(f);
 
179
}
 
180
 
 
181
 
 
182
void ms_filter_process(MSFilter *f){
 
183
        ms_debug("Executing process of filter %s:%p",f->desc->name,f);
 
184
        f->desc->process(f);
 
185
}
 
186
 
 
187
void ms_filter_preprocess(MSFilter *f, struct _MSTicker *t){
 
188
        f->seen=FALSE;
 
189
        f->last_tick=0;
 
190
        f->ticker=t;
 
191
        if (f->desc->preprocess!=NULL)
 
192
                f->desc->preprocess(f);
 
193
}
 
194
 
 
195
void ms_filter_postprocess(MSFilter *f){
 
196
        if (f->desc->postprocess!=NULL)
 
197
                f->desc->postprocess(f);
 
198
        f->seen=FALSE;
 
199
        f->ticker=NULL;
 
200
}
 
201
 
 
202
bool_t ms_filter_inputs_have_data(MSFilter *f){
 
203
        int i;
 
204
        for(i=0;i<f->desc->ninputs;i++){
 
205
                MSQueue *q=f->inputs[i];
 
206
                if (q!=NULL && q->q.q_mcount>0) return TRUE;
 
207
        }
 
208
        return FALSE;
 
209
}
 
210
 
 
211
void ms_filter_notify(MSFilter *f, unsigned int id, void *arg){
 
212
        if (f->notify!=NULL)
 
213
                f->notify(f->notify_ud,id,arg);
 
214
}
 
215
 
 
216
void ms_filter_notify_no_arg(MSFilter *f, unsigned int id){
 
217
        if (f->notify!=NULL)
 
218
                f->notify(f->notify_ud,id,NULL);
 
219
}