1 /*
2 mediastreamer2 library - modular sound and video processing and streaming
3 Copyright (C) 2006-2013 Belledonne Communications, Grenoble
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 */
19
20 #include "mediastreamer2/mediastream.h"
21 #include "mediastreamer2/dtmfgen.h"
22 #include "mediastreamer2/msfileplayer.h"
23 #include "mediastreamer2/msfilerec.h"
24 #include "mediastreamer2/msrtp.h"
25 #include "mediastreamer2/mstonedetector.h"
26 #include "mediastreamer2_tester.h"
27 #include "mediastreamer2_tester_private.h"
28
29 #ifdef _MSC_VER
30 #pragma warning(disable : 4996)
31 #else
32 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
33 #endif
34
sound_card_tester_before_all(void)35 static int sound_card_tester_before_all(void) {
36 ms_init();
37 ms_filter_enable_statistics(TRUE);
38 return 0;
39 }
40
sound_card_tester_after_all(void)41 static int sound_card_tester_after_all(void) {
42 ms_exit();
43 return 0;
44 }
45
configure_resampler(MSFilter * resampler,MSFilter * from,MSFilter * to)46 static void configure_resampler(MSFilter *resampler, MSFilter *from, MSFilter *to) {
47 int from_rate = 0, to_rate = 0;
48 int from_channels = 0, to_channels = 0;
49 ms_filter_call_method(from, MS_FILTER_GET_SAMPLE_RATE, &from_rate);
50 ms_filter_call_method(to, MS_FILTER_GET_SAMPLE_RATE, &to_rate);
51 ms_filter_call_method(resampler, MS_FILTER_SET_SAMPLE_RATE, &from_rate);
52 ms_filter_call_method(resampler, MS_FILTER_SET_OUTPUT_SAMPLE_RATE, &to_rate);
53 ms_filter_call_method(from, MS_FILTER_GET_NCHANNELS, &from_channels);
54 ms_filter_call_method(to, MS_FILTER_GET_NCHANNELS, &to_channels);
55 if (from_channels == 0) from_channels = 1;
56 if (to_channels == 0) to_channels = 1;
57 ms_filter_call_method(resampler, MS_FILTER_SET_NCHANNELS, &from_channels);
58 ms_filter_call_method(resampler, MS_FILTER_SET_OUTPUT_NCHANNELS, &to_channels);
59 }
60
dtmfgen_soundwrite(void)61 static void dtmfgen_soundwrite(void) {
62 MSConnectionHelper h;
63 bool_t need_resampler = FALSE;
64 unsigned int filter_mask = FILTER_MASK_VOIDSOURCE | FILTER_MASK_DTMFGEN | FILTER_MASK_SOUNDWRITE;
65 int sample_rate = 8000;
66 int nchannels = 1;
67 bool_t send_silence = TRUE;
68
69 ms_filter_reset_statistics();
70 ms_tester_create_ticker();
71 ms_tester_create_filters(filter_mask, ms_factory_get_fallback());
72 ms_filter_call_method(ms_tester_voidsource, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
73 ms_filter_call_method(ms_tester_voidsource, MS_FILTER_SET_NCHANNELS, &nchannels);
74 ms_filter_call_method(ms_tester_voidsource, MS_VOID_SOURCE_SEND_SILENCE, &send_silence);
75 ms_filter_call_method(ms_tester_dtmfgen, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
76 ms_filter_call_method(ms_tester_dtmfgen, MS_FILTER_SET_NCHANNELS, &nchannels);
77 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_SAMPLE_RATE, &sample_rate) != 0) {
78 need_resampler = TRUE;
79 }
80 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
81 need_resampler = TRUE;
82 }
83 if (need_resampler == TRUE) {
84 ms_tester_create_filters(FILTER_MASK_RESAMPLER, ms_factory_get_fallback());
85 configure_resampler(ms_tester_resampler, ms_tester_dtmfgen, ms_tester_soundwrite);
86 }
87 ms_connection_helper_start(&h);
88 ms_connection_helper_link(&h, ms_tester_voidsource, -1, 0);
89 ms_connection_helper_link(&h, ms_tester_dtmfgen, 0, 0);
90 if (need_resampler == TRUE) {
91 ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
92 }
93 ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
94 ms_ticker_attach(ms_tester_ticker, ms_tester_voidsource);
95
96 ms_tester_tone_generation_loop();
97
98 ms_ticker_detach(ms_tester_ticker, ms_tester_voidsource);
99 ms_connection_helper_start(&h);
100 ms_connection_helper_unlink(&h, ms_tester_voidsource, -1, 0);
101 ms_connection_helper_unlink(&h, ms_tester_dtmfgen, 0, 0);
102 if (need_resampler == TRUE) {
103 ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
104 }
105 ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
106 if (need_resampler == TRUE) {
107 ms_tester_destroy_filters(FILTER_MASK_RESAMPLER);
108 }
109 ms_filter_log_statistics();
110 ms_tester_destroy_filters(filter_mask);
111 ms_tester_destroy_ticker();
112 }
113
114 #define CHIMES_48000_STEREO_FILE_NAME "sounds/chimes_48000_stereo.wav"
115 #define BIRD_44100_STEREO_FILE_NAME "sounds/bird_44100_stereo.wav"
116 #define PUNCH_16000_STEREO_FILE_NAME "sounds/punch_16000_stereo.wav"
117 #define PIANO_8000_STEREO_FILE_NAME "sounds/piano_8000_stereo.wav"
118 #define NYLON_48000_MONO_FILE_NAME "sounds/nylon_48000_mono.wav"
119 #define OWL_44100_MONO_FILE_NAME "sounds/owl_44100_mono.wav"
120 #define LASERROCKET_16000_MONO_FILE_NAME "sounds/laserrocket_16000_mono.wav"
121 #define ARPEGGIO_8000_MONO_FILE_NAME "sounds/arpeggio_8000_mono.wav"
122
fileplay_eof(void * user_data,MSFilter * f,unsigned int event,void * event_data)123 static void fileplay_eof(void *user_data, MSFilter *f, unsigned int event, void *event_data) {
124 if (event == MS_FILE_PLAYER_EOF) {
125 int *done = (int *)user_data;
126 *done = TRUE;
127 }
128 MS_UNUSED(f), MS_UNUSED(event_data);
129 }
130
fileplay_soundwrite(const char * filename)131 static void fileplay_soundwrite(const char *filename) {
132 MSConnectionHelper h;
133 bool_t need_resampler = FALSE;
134 unsigned int filter_mask = FILTER_MASK_FILEPLAY | FILTER_MASK_SOUNDWRITE;
135 int sample_rate = 8000;
136 int nchannels = 1;
137 int done = FALSE;
138 int elapsed = 0;
139
140 ms_filter_reset_statistics();
141 ms_tester_create_ticker();
142 ms_tester_create_filters(filter_mask, ms_factory_get_fallback());
143 ms_filter_add_notify_callback(ms_tester_fileplay, fileplay_eof, &done,TRUE);
144 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
145 ms_filter_call_method(ms_tester_fileplay, MS_FILE_PLAYER_OPEN, (void *)filename);
146 ms_filter_call_method(ms_tester_fileplay, MS_FILTER_GET_SAMPLE_RATE, &sample_rate);
147 ms_filter_call_method(ms_tester_fileplay, MS_FILTER_GET_NCHANNELS, &nchannels);
148 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_SAMPLE_RATE, &sample_rate) != 0) {
149 int soundwrite_sample_rate = 48000;
150 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_SAMPLE_RATE, &soundwrite_sample_rate);
151 if (sample_rate != soundwrite_sample_rate) need_resampler = TRUE;
152 }
153 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
154 int soundwrite_nchannels = 1;
155 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &soundwrite_nchannels);
156 if (nchannels != soundwrite_nchannels) need_resampler = TRUE;
157 }
158 if (need_resampler == TRUE) {
159 ms_tester_create_filters(FILTER_MASK_RESAMPLER, ms_factory_get_fallback());
160 configure_resampler(ms_tester_resampler, ms_tester_fileplay, ms_tester_soundwrite);
161 }
162 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_START);
163 ms_connection_helper_start(&h);
164 ms_connection_helper_link(&h, ms_tester_fileplay, -1, 0);
165 if (need_resampler == TRUE) {
166 ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
167 }
168 ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
169 ms_ticker_attach(ms_tester_ticker, ms_tester_fileplay);
170
171
172 while (done != TRUE && elapsed < 6000) {
173 elapsed++;
174 ms_usleep(10000);
175 }
176
177 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
178 ms_ticker_detach(ms_tester_ticker, ms_tester_fileplay);
179 ms_connection_helper_start(&h);
180 ms_connection_helper_unlink(&h, ms_tester_fileplay, -1, 0);
181 if (need_resampler == TRUE) {
182 ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
183 }
184 ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
185 if (need_resampler == TRUE) {
186 ms_tester_destroy_filters(FILTER_MASK_RESAMPLER);
187 }
188 ms_filter_log_statistics();
189 ms_tester_destroy_filters(filter_mask);
190 ms_tester_destroy_ticker();
191 }
192
fileplay_soundwrite_from_file(const char * filepath)193 static void fileplay_soundwrite_from_file(const char *filepath){
194 char* file = bc_tester_res(filepath);
195 fileplay_soundwrite(file);
196 free(file);
197 }
198
fileplay_soundwrite_48000_stereo(void)199 static void fileplay_soundwrite_48000_stereo(void) {
200 fileplay_soundwrite_from_file(CHIMES_48000_STEREO_FILE_NAME);
201 }
202
fileplay_soundwrite_44100_stereo(void)203 static void fileplay_soundwrite_44100_stereo(void) {
204 fileplay_soundwrite_from_file(BIRD_44100_STEREO_FILE_NAME);
205 }
206
fileplay_soundwrite_16000_stereo(void)207 static void fileplay_soundwrite_16000_stereo(void) {
208 fileplay_soundwrite_from_file(PUNCH_16000_STEREO_FILE_NAME);
209 }
210
fileplay_soundwrite_8000_stereo(void)211 static void fileplay_soundwrite_8000_stereo(void) {
212 fileplay_soundwrite_from_file(PIANO_8000_STEREO_FILE_NAME);
213 }
214
fileplay_soundwrite_48000_mono(void)215 static void fileplay_soundwrite_48000_mono(void) {
216 fileplay_soundwrite_from_file(NYLON_48000_MONO_FILE_NAME);
217 }
218
fileplay_soundwrite_44100_mono(void)219 static void fileplay_soundwrite_44100_mono(void) {
220 fileplay_soundwrite_from_file(OWL_44100_MONO_FILE_NAME);
221 }
222
fileplay_soundwrite_16000_mono(void)223 static void fileplay_soundwrite_16000_mono(void) {
224 fileplay_soundwrite_from_file(LASERROCKET_16000_MONO_FILE_NAME);
225 }
226
fileplay_soundwrite_8000_mono(void)227 static void fileplay_soundwrite_8000_mono(void) {
228 fileplay_soundwrite_from_file(ARPEGGIO_8000_MONO_FILE_NAME);
229 }
230
soundread_soundwrite(void)231 static void soundread_soundwrite(void) {
232 MSConnectionHelper h;
233 bool_t need_resampler = FALSE;
234 unsigned int filter_mask = FILTER_MASK_SOUNDREAD | FILTER_MASK_SOUNDWRITE;
235 int sample_rate = 8000;
236 int nchannels = 1;
237
238 ms_filter_reset_statistics();
239 ms_tester_create_ticker();
240 ms_tester_create_filters(filter_mask, ms_factory_get_fallback());
241 ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_SAMPLE_RATE, &sample_rate);
242 ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_NCHANNELS, &nchannels);
243 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_SAMPLE_RATE, &sample_rate) != 0) {
244 int soundwrite_sample_rate = 48000;
245 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_SAMPLE_RATE, &soundwrite_sample_rate);
246 if (sample_rate != soundwrite_sample_rate) need_resampler = TRUE;
247 }
248 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
249 int soundwrite_nchannels = 1;
250 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &soundwrite_nchannels);
251 if (nchannels != soundwrite_nchannels) need_resampler = TRUE;
252 }
253 if (need_resampler == TRUE) {
254 ms_tester_create_filters(FILTER_MASK_RESAMPLER, ms_factory_get_fallback());
255 configure_resampler(ms_tester_resampler, ms_tester_soundread, ms_tester_soundwrite);
256 }
257 ms_connection_helper_start(&h);
258 ms_connection_helper_link(&h, ms_tester_soundread, -1, 0);
259 if (need_resampler == TRUE) {
260 ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
261 }
262 ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
263 ms_ticker_attach(ms_tester_ticker, ms_tester_soundread);
264
265 ms_sleep(3);
266
267 ms_ticker_detach(ms_tester_ticker, ms_tester_soundread);
268 ms_connection_helper_start(&h);
269 ms_connection_helper_unlink(&h, ms_tester_soundread, -1, 0);
270 if (need_resampler == TRUE) {
271 ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
272 }
273 ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
274 if (need_resampler == TRUE) {
275 ms_tester_destroy_filters(FILTER_MASK_RESAMPLER);
276 }
277 ms_filter_log_statistics();
278 ms_tester_destroy_filters(filter_mask);
279 ms_tester_destroy_ticker();
280 }
281
fileplay_bv16enc_bv16dec_soundwrite(void)282 static void fileplay_bv16enc_bv16dec_soundwrite(void) {
283 if (ms_factory_codec_supported(ms_factory_get_fallback(), "bv16")) {
284 MSConnectionHelper h;
285 MSFilter *read_resampler = NULL, *write_resampler = NULL;
286 bool_t need_read_resampler = FALSE, need_write_resampler = TRUE;
287 unsigned int filter_mask = FILTER_MASK_FILEPLAY | FILTER_MASK_ENCODER | FILTER_MASK_DECODER | FILTER_MASK_SOUNDWRITE;
288 int sample_rate = 8000;
289 int nchannels = 1;
290 int done = FALSE;
291 const char* filepath = ARPEGGIO_8000_MONO_FILE_NAME;
292
293 char* filename = bc_tester_res(filepath);
294
295 int elapsed = 0;
296
297 ms_filter_reset_statistics();
298 ms_tester_create_ticker();
299 ms_tester_codec_mime = "bv16";
300 ms_tester_create_filters(filter_mask, ms_factory_get_fallback());
301
302
303 //file
304 ms_filter_add_notify_callback(ms_tester_fileplay, fileplay_eof, &done,TRUE);
305 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
306
307 ms_filter_call_method(ms_tester_fileplay, MS_FILE_PLAYER_OPEN, (void *)filename);
308 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_START);
309 ms_filter_call_method(ms_tester_fileplay, MS_FILTER_GET_SAMPLE_RATE, &sample_rate);
310 ms_filter_call_method(ms_tester_fileplay, MS_FILTER_GET_NCHANNELS, &nchannels);
311
312 ms_filter_call_method(ms_tester_encoder, MS_FILTER_GET_BITRATE, &sample_rate);
313 ms_filter_call_method(ms_tester_decoder, MS_FILTER_SET_BITRATE, &sample_rate);
314
315
316 if (need_read_resampler == TRUE) {
317 ms_tester_create_filters(FILTER_MASK_RESAMPLER, ms_factory_get_fallback());
318 configure_resampler(ms_tester_resampler, ms_tester_fileplay, ms_tester_encoder);
319 }
320
321
322 ms_connection_helper_start(&h);
323 ms_connection_helper_link(&h, ms_tester_fileplay, -1, 0);
324 if (need_read_resampler == TRUE) {
325 ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
326 }
327
328 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_BITRATE, &sample_rate) != 0) {
329 int soundwrite_sample_rate = 8000;
330 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_BITRATE, &soundwrite_sample_rate);
331 if (sample_rate != soundwrite_sample_rate) need_write_resampler = TRUE;
332 }
333 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
334 int soundwrite_nchannels = 1;
335 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &soundwrite_nchannels);
336 if (nchannels != soundwrite_nchannels) need_write_resampler = TRUE;
337 }
338 if (need_write_resampler == TRUE) {
339 ms_tester_create_filter(&write_resampler, MS_RESAMPLE_ID, ms_factory_get_fallback());
340 configure_resampler(write_resampler, ms_tester_decoder, ms_tester_soundwrite);
341 }
342
343 ms_connection_helper_link(&h, ms_tester_encoder, 0, 0);
344 ms_connection_helper_link(&h, ms_tester_decoder, 0, 0);
345 if (need_write_resampler == TRUE) {
346 ms_connection_helper_link(&h, write_resampler, 0, 0);
347 }
348 ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
349 ms_ticker_attach(ms_tester_ticker, ms_tester_fileplay);
350
351
352 while (done != TRUE && elapsed < 6000) {
353 elapsed++;
354 ms_usleep(10000);
355 }
356
357 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
358 ms_ticker_detach(ms_tester_ticker, ms_tester_fileplay);
359 ms_connection_helper_start(&h);
360 ms_connection_helper_unlink(&h, ms_tester_fileplay, -1, 0);
361 if (need_read_resampler == TRUE) {
362 ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
363 }
364 ms_connection_helper_unlink(&h, ms_tester_encoder, 0, 0);
365 ms_connection_helper_unlink(&h, ms_tester_decoder, 0, 0);
366 if (need_write_resampler == TRUE) {
367 ms_connection_helper_unlink(&h, write_resampler, 0, 0);
368 }
369 ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
370 if (need_read_resampler == TRUE) {
371 ms_tester_destroy_filter(&read_resampler);
372 }
373 if (need_write_resampler == TRUE) {
374 ms_tester_destroy_filter(&write_resampler);
375 }
376 ms_filter_log_statistics();
377 ms_tester_destroy_filters(filter_mask);
378 ms_tester_destroy_ticker();
379 free(filename);
380 }
381 }
382
soundread_speexenc_speexdec_soundwrite(void)383 static void soundread_speexenc_speexdec_soundwrite(void) {
384 MSConnectionHelper h;
385 MSFilter *read_resampler = NULL, *write_resampler = NULL;
386 bool_t need_read_resampler = FALSE, need_write_resampler = FALSE;
387 unsigned int filter_mask = FILTER_MASK_SOUNDREAD | FILTER_MASK_ENCODER | FILTER_MASK_DECODER | FILTER_MASK_SOUNDWRITE;
388 int sample_rate = 8000;
389 int nchannels = 1;
390
391 ms_filter_reset_statistics();
392 ms_tester_create_ticker();
393 ms_tester_codec_mime = "speex";
394 ms_tester_create_filters(filter_mask, ms_factory_get_fallback());
395 ms_filter_call_method(ms_tester_encoder, MS_FILTER_GET_BITRATE, &sample_rate);
396 ms_filter_call_method(ms_tester_decoder, MS_FILTER_SET_BITRATE, &sample_rate);
397 if (ms_filter_call_method(ms_tester_soundread, MS_FILTER_SET_BITRATE, &sample_rate) != 0) {
398 int soundread_sample_rate = 48000;
399 ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_BITRATE, &soundread_sample_rate);
400 if (sample_rate != soundread_sample_rate) need_read_resampler = TRUE;
401 }
402 if (ms_filter_call_method(ms_tester_soundread, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
403 int soundread_nchannels = 1;
404 ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_NCHANNELS, &soundread_nchannels);
405 if (nchannels != soundread_nchannels) need_read_resampler = TRUE;
406 }
407 if (need_read_resampler == TRUE) {
408 ms_tester_create_filter(&read_resampler, MS_RESAMPLE_ID, ms_factory_get_fallback());
409 configure_resampler(read_resampler, ms_tester_soundread, ms_tester_encoder);
410 }
411 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_BITRATE, &sample_rate) != 0) {
412 int soundwrite_sample_rate = 48000;
413 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_BITRATE, &soundwrite_sample_rate);
414 if (sample_rate != soundwrite_sample_rate) need_write_resampler = TRUE;
415 }
416 if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
417 int soundwrite_nchannels = 1;
418 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &soundwrite_nchannels);
419 if (nchannels != soundwrite_nchannels) need_write_resampler = TRUE;
420 }
421 if (need_write_resampler == TRUE) {
422 ms_tester_create_filter(&write_resampler, MS_RESAMPLE_ID, ms_factory_get_fallback());
423 configure_resampler(write_resampler, ms_tester_decoder, ms_tester_soundwrite);
424 }
425 ms_connection_helper_start(&h);
426 ms_connection_helper_link(&h, ms_tester_soundread, -1, 0);
427 if (need_read_resampler == TRUE) {
428 ms_connection_helper_link(&h, read_resampler, 0, 0);
429 }
430 ms_connection_helper_link(&h, ms_tester_encoder, 0, 0);
431 ms_connection_helper_link(&h, ms_tester_decoder, 0, 0);
432 if (need_write_resampler == TRUE) {
433 ms_connection_helper_link(&h, write_resampler, 0, 0);
434 }
435 ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
436 ms_ticker_attach(ms_tester_ticker, ms_tester_soundread);
437
438 ms_sleep(5);
439
440 ms_ticker_detach(ms_tester_ticker, ms_tester_soundread);
441 ms_connection_helper_start(&h);
442 ms_connection_helper_unlink(&h, ms_tester_soundread, -1, 0);
443 if (need_read_resampler == TRUE) {
444 ms_connection_helper_unlink(&h, read_resampler, 0, 0);
445 }
446 ms_connection_helper_unlink(&h, ms_tester_encoder, 0, 0);
447 ms_connection_helper_unlink(&h, ms_tester_decoder, 0, 0);
448 if (need_write_resampler == TRUE) {
449 ms_connection_helper_unlink(&h, write_resampler, 0, 0);
450 }
451 ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
452 if (need_read_resampler == TRUE) {
453 ms_tester_destroy_filter(&read_resampler);
454 }
455 if (need_write_resampler == TRUE) {
456 ms_tester_destroy_filter(&write_resampler);
457 }
458 ms_filter_log_statistics();
459 ms_tester_destroy_filters(filter_mask);
460 ms_tester_destroy_ticker();
461 }
462
463 #define SOUNDREAD_FILE_NAME "soundread_file.raw"
464
soundread_filerec_fileplay_soundwrite(void)465 static void soundread_filerec_fileplay_soundwrite(void) {
466 MSConnectionHelper h;
467 unsigned int filter_mask = FILTER_MASK_SOUNDREAD | FILTER_MASK_FILEREC | FILTER_MASK_FILEPLAY | FILTER_MASK_SOUNDWRITE;
468 int capture_sample_rate = 8000;
469 int playback_sample_rate = 8000;
470 int capture_nchannels = 1;
471 int playback_nchannels = 1;
472 char *writable_filename = bc_tester_file(SOUNDREAD_FILE_NAME);
473
474 ms_filter_reset_statistics();
475 ms_tester_create_ticker();
476 ms_tester_create_filters(filter_mask, ms_factory_get_fallback());
477
478 // Write audio capture to a file
479 ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_SAMPLE_RATE, &capture_sample_rate);
480 ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_NCHANNELS, &capture_nchannels);
481 ms_filter_call_method(ms_tester_filerec, MS_FILTER_SET_SAMPLE_RATE, &capture_sample_rate);
482 ms_filter_call_method(ms_tester_filerec, MS_FILTER_SET_NCHANNELS, &capture_nchannels);
483 ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_CLOSE);
484 ms_filter_call_method(ms_tester_filerec, MS_FILE_REC_OPEN, writable_filename);
485 ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_START);
486 ms_connection_helper_start(&h);
487 ms_connection_helper_link(&h, ms_tester_soundread, -1, 0);
488 ms_connection_helper_link(&h, ms_tester_filerec, 0, -1);
489 ms_ticker_attach(ms_tester_ticker, ms_tester_soundread);
490
491 ms_sleep(4);
492
493 ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_CLOSE);
494 ms_ticker_detach(ms_tester_ticker, ms_tester_soundread);
495 ms_connection_helper_start(&h);
496 ms_connection_helper_unlink(&h, ms_tester_soundread, -1, 0);
497 ms_connection_helper_unlink(&h, ms_tester_filerec, 0, -1);
498
499 // Read the previous file and play it
500 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_SAMPLE_RATE, &playback_sample_rate);
501 ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &playback_nchannels);
502 if ((capture_sample_rate != playback_sample_rate) || (capture_nchannels != playback_nchannels)) {
503 ms_tester_create_filter(&ms_tester_resampler, MS_RESAMPLE_ID, ms_factory_get_fallback());
504 }
505 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
506 ms_filter_call_method(ms_tester_fileplay, MS_FILE_PLAYER_OPEN, writable_filename);
507 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_START);
508 ms_connection_helper_start(&h);
509 ms_connection_helper_link(&h, ms_tester_fileplay, -1, 0);
510 if (ms_tester_resampler != NULL) {
511 ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
512 ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_SAMPLE_RATE, &capture_sample_rate);
513 ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_OUTPUT_SAMPLE_RATE, &playback_sample_rate);
514 ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_NCHANNELS, &capture_nchannels);
515 ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_OUTPUT_NCHANNELS, &capture_nchannels);
516 }
517 ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
518 ms_ticker_attach(ms_tester_ticker, ms_tester_fileplay);
519
520 ms_sleep(4);
521
522 ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
523 ms_ticker_detach(ms_tester_ticker, ms_tester_fileplay);
524 ms_connection_helper_start(&h);
525 ms_connection_helper_unlink(&h, ms_tester_fileplay, -1, 0);
526 if (ms_tester_resampler != NULL) {
527 ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
528 }
529 ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
530 ms_filter_log_statistics();
531 ms_tester_destroy_filters(filter_mask);
532 ms_tester_destroy_ticker();
533
534 unlink(writable_filename);
535 free(writable_filename);
536 }
537
538
539 test_t sound_card_tests[] = {
540 TEST_NO_TAG("dtmfgen-soundwrite", dtmfgen_soundwrite),
541 TEST_NO_TAG("fileplay-soundwrite-48000-stereo", fileplay_soundwrite_48000_stereo),
542 TEST_NO_TAG("fileplay-soundwrite-44100-stereo", fileplay_soundwrite_44100_stereo),
543 TEST_NO_TAG("fileplay-soundwrite-16000-stereo", fileplay_soundwrite_16000_stereo),
544 TEST_NO_TAG("fileplay-soundwrite-8000-stereo", fileplay_soundwrite_8000_stereo),
545 TEST_NO_TAG("fileplay-soundwrite-48000-mono", fileplay_soundwrite_48000_mono),
546 TEST_NO_TAG("fileplay-soundwrite-44100-mono", fileplay_soundwrite_44100_mono),
547 TEST_NO_TAG("fileplay-soundwrite-16000-mono", fileplay_soundwrite_16000_mono),
548 TEST_NO_TAG("fileplay-soundwrite-8000-mono", fileplay_soundwrite_8000_mono),
549 TEST_NO_TAG("soundread-soundwrite", soundread_soundwrite),
550 TEST_NO_TAG("soundread-speexenc-speexdec-soundwrite", soundread_speexenc_speexdec_soundwrite),
551 TEST_NO_TAG("soundread-filerec-fileplay-soundwrite", soundread_filerec_fileplay_soundwrite),
552 TEST_NO_TAG("fileplay-bv16enc-bv16dec-soundwrite", fileplay_bv16enc_bv16dec_soundwrite)
553 };
554
555 test_suite_t sound_card_test_suite = {
556 "Sound Card",
557 sound_card_tester_before_all,
558 sound_card_tester_after_all,
559 NULL,
560 NULL,
561 sizeof(sound_card_tests) / sizeof(sound_card_tests[0]),
562 sound_card_tests
563 };
564