]> code.delx.au - pulseaudio/blob - src/tests/resampler-test.c
delx.au / code / pulseaudio / blob


12d06d2710a090f4d9dc13882f00bf32eb4f9ed4
[pulseaudio] / src / tests / resampler-test.c
1 /***
2 This file is part of PulseAudio.
3
4 PulseAudio is free software; you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as published
6 by the Free Software Foundation; either version 2.1 of the License,
7 or (at your option) any later version.
8
9 PulseAudio is distributed in the hope that it will be useful, but
10 WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with PulseAudio; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17 USA.
18 ***/
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <stdio.h>
25 #include <getopt.h>
26 #include <locale.h>
27
28 #include <pulse/pulseaudio.h>
29
30 #include <pulse/rtclock.h>
31 #include <pulse/sample.h>
32 #include <pulse/volume.h>
33
34 #include <pulsecore/i18n.h>
35 #include <pulsecore/resampler.h>
36 #include <pulsecore/macro.h>
37 #include <pulsecore/endianmacros.h>
38 #include <pulsecore/memblock.h>
39 #include <pulsecore/sample-util.h>
40 #include <pulsecore/core-util.h>
41
42 static void dump_block(const pa_sample_spec *ss, const pa_memchunk *chunk) {
43 void *d;
44 unsigned i;
45
46 d = pa_memblock_acquire(chunk->memblock);
47
48 switch (ss->format) {
49
50 case PA_SAMPLE_U8:
51 case PA_SAMPLE_ULAW:
52 case PA_SAMPLE_ALAW: {
53 uint8_t *u = d;
54
55 for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
56 printf(" 0x%02x ", *(u++));
57
58 break;
59 }
60
61 case PA_SAMPLE_S16NE:
62 case PA_SAMPLE_S16RE: {
63 uint16_t *u = d;
64
65 for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
66 printf(" 0x%04x ", *(u++));
67
68 break;
69 }
70
71 case PA_SAMPLE_S32NE:
72 case PA_SAMPLE_S32RE: {
73 uint32_t *u = d;
74
75 for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
76 printf("0x%08x ", *(u++));
77
78 break;
79 }
80
81 case PA_SAMPLE_S24_32NE:
82 case PA_SAMPLE_S24_32RE: {
83 uint32_t *u = d;
84
85 for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
86 printf("0x%08x ", *(u++));
87
88 break;
89 }
90
91 case PA_SAMPLE_FLOAT32NE:
92 case PA_SAMPLE_FLOAT32RE: {
93 float *u = d;
94
95 for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
96 printf("%4.3g ", ss->format == PA_SAMPLE_FLOAT32NE ? *u : PA_FLOAT32_SWAP(*u));
97 u++;
98 }
99
100 break;
101 }
102
103 case PA_SAMPLE_S24LE:
104 case PA_SAMPLE_S24BE: {
105 uint8_t *u = d;
106
107 for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
108 printf(" 0x%06x ", PA_READ24NE(u));
109 u += pa_frame_size(ss);
110 }
111
112 break;
113 }
114
115 default:
116 pa_assert_not_reached();
117 }
118
119 printf("\n");
120
121 pa_memblock_release(chunk->memblock);
122 }
123
124 static pa_memblock* generate_block(pa_mempool *pool, const pa_sample_spec *ss) {
125 pa_memblock *r;
126 void *d;
127 unsigned i;
128
129 pa_assert_se(r = pa_memblock_new(pool, pa_frame_size(ss) * 10));
130 d = pa_memblock_acquire(r);
131
132 switch (ss->format) {
133
134 case PA_SAMPLE_U8:
135 case PA_SAMPLE_ULAW:
136 case PA_SAMPLE_ALAW: {
137 uint8_t *u = d;
138
139 u[0] = 0x00;
140 u[1] = 0xFF;
141 u[2] = 0x7F;
142 u[3] = 0x80;
143 u[4] = 0x9f;
144 u[5] = 0x3f;
145 u[6] = 0x1;
146 u[7] = 0xF0;
147 u[8] = 0x20;
148 u[9] = 0x21;
149 break;
150 }
151
152 case PA_SAMPLE_S16NE:
153 case PA_SAMPLE_S16RE: {
154 uint16_t *u = d;
155
156 u[0] = 0x0000;
157 u[1] = 0xFFFF;
158 u[2] = 0x7FFF;
159 u[3] = 0x8000;
160 u[4] = 0x9fff;
161 u[5] = 0x3fff;
162 u[6] = 0x1;
163 u[7] = 0xF000;
164 u[8] = 0x20;
165 u[9] = 0x21;
166 break;
167 }
168
169 case PA_SAMPLE_S32NE:
170 case PA_SAMPLE_S32RE: {
171 uint32_t *u = d;
172
173 u[0] = 0x00000001;
174 u[1] = 0xFFFF0002;
175 u[2] = 0x7FFF0003;
176 u[3] = 0x80000004;
177 u[4] = 0x9fff0005;
178 u[5] = 0x3fff0006;
179 u[6] = 0x10007;
180 u[7] = 0xF0000008;
181 u[8] = 0x200009;
182 u[9] = 0x21000A;
183 break;
184 }
185
186 case PA_SAMPLE_S24_32NE:
187 case PA_SAMPLE_S24_32RE: {
188 uint32_t *u = d;
189
190 u[0] = 0x000001;
191 u[1] = 0xFF0002;
192 u[2] = 0x7F0003;
193 u[3] = 0x800004;
194 u[4] = 0x9f0005;
195 u[5] = 0x3f0006;
196 u[6] = 0x107;
197 u[7] = 0xF00008;
198 u[8] = 0x2009;
199 u[9] = 0x210A;
200 break;
201 }
202
203 case PA_SAMPLE_FLOAT32NE:
204 case PA_SAMPLE_FLOAT32RE: {
205 float *u = d;
206
207 u[0] = 0.0f;
208 u[1] = -1.0f;
209 u[2] = 1.0f;
210 u[3] = 4711.0f;
211 u[4] = 0.222f;
212 u[5] = 0.33f;
213 u[6] = -.3f;
214 u[7] = 99.0f;
215 u[8] = -0.555f;
216 u[9] = -.123f;
217
218 if (ss->format == PA_SAMPLE_FLOAT32RE)
219 for (i = 0; i < 10; i++)
220 u[i] = PA_FLOAT32_SWAP(u[i]);
221
222 break;
223 }
224
225 case PA_SAMPLE_S24NE:
226 case PA_SAMPLE_S24RE: {
227 uint8_t *u = d;
228
229 PA_WRITE24NE(u, 0x000001);
230 PA_WRITE24NE(u+3, 0xFF0002);
231 PA_WRITE24NE(u+6, 0x7F0003);
232 PA_WRITE24NE(u+9, 0x800004);
233 PA_WRITE24NE(u+12, 0x9f0005);
234 PA_WRITE24NE(u+15, 0x3f0006);
235 PA_WRITE24NE(u+18, 0x107);
236 PA_WRITE24NE(u+21, 0xF00008);
237 PA_WRITE24NE(u+24, 0x2009);
238 PA_WRITE24NE(u+27, 0x210A);
239 break;
240 }
241
242 default:
243 pa_assert_not_reached();
244 }
245
246 pa_memblock_release(r);
247
248 return r;
249 }
250
251 static void help(const char *argv0) {
252 printf(_("%s [options]\n\n"
253 "-h, --help Show this help\n"
254 "-v, --verbose Print debug messages\n"
255 " --from-rate=SAMPLERATE From sample rate in Hz (defaults to 44100)\n"
256 " --from-format=SAMPLEFORMAT From sample type (defaults to s16le)\n"
257 " --from-channels=CHANNELS From number of channels (defaults to 1)\n"
258 " --to-rate=SAMPLERATE To sample rate in Hz (defaults to 44100)\n"
259 " --to-format=SAMPLEFORMAT To sample type (defaults to s16le)\n"
260 " --to-channels=CHANNELS To number of channels (defaults to 1)\n"
261 " --resample-method=METHOD Resample method (defaults to auto)\n"
262 " --seconds=SECONDS From stream duration (defaults to 60)\n"
263 "\n"
264 "If the formats are not specified, the test performs all formats combinations,\n"
265 "back and forth.\n"
266 "\n"
267 "Sample type must be one of s16le, s16be, u8, float32le, float32be, ulaw, alaw,\n"
268 "32le, s32be (defaults to s16ne)\n"
269 "\n"
270 "See --dump-resample-methods for possible values of resample methods.\n"),
271 argv0);
272 }
273
274 enum {
275 ARG_VERSION = 256,
276 ARG_FROM_SAMPLERATE,
277 ARG_FROM_SAMPLEFORMAT,
278 ARG_FROM_CHANNELS,
279 ARG_TO_SAMPLERATE,
280 ARG_TO_SAMPLEFORMAT,
281 ARG_TO_CHANNELS,
282 ARG_SECONDS,
283 ARG_RESAMPLE_METHOD,
284 ARG_DUMP_RESAMPLE_METHODS
285 };
286
287 static void dump_resample_methods(void) {
288 int i;
289
290 for (i = 0; i < PA_RESAMPLER_MAX; i++)
291 if (pa_resample_method_supported(i))
292 printf("%s\n", pa_resample_method_to_string(i));
293
294 }
295
296 int main(int argc, char *argv[]) {
297 pa_mempool *pool = NULL;
298 pa_sample_spec a, b;
299 int ret = 1, verbose = 0, c;
300 pa_bool_t all_formats = TRUE;
301 pa_resample_method_t method;
302 int seconds;
303
304 static const struct option long_options[] = {
305 {"help", 0, NULL, 'h'},
306 {"verbose", 0, NULL, 'v'},
307 {"version", 0, NULL, ARG_VERSION},
308 {"from-rate", 1, NULL, ARG_FROM_SAMPLERATE},
309 {"from-format", 1, NULL, ARG_FROM_SAMPLEFORMAT},
310 {"from-channels", 1, NULL, ARG_FROM_CHANNELS},
311 {"to-rate", 1, NULL, ARG_TO_SAMPLERATE},
312 {"to-format", 1, NULL, ARG_TO_SAMPLEFORMAT},
313 {"to-channels", 1, NULL, ARG_TO_CHANNELS},
314 {"seconds", 1, NULL, ARG_SECONDS},
315 {"resample-method", 1, NULL, ARG_RESAMPLE_METHOD},
316 {"dump-resample-methods", 0, NULL, ARG_DUMP_RESAMPLE_METHODS},
317 {NULL, 0, NULL, 0}
318 };
319
320 setlocale(LC_ALL, "");
321 bindtextdomain(GETTEXT_PACKAGE, PULSE_LOCALEDIR);
322
323 pa_log_set_level(PA_LOG_DEBUG);
324
325 pa_assert_se(pool = pa_mempool_new(FALSE, 0));
326
327 a.channels = b.channels = 1;
328 a.rate = b.rate = 44100;
329 a.format = b.format = PA_SAMPLE_S16LE;
330
331 method = PA_RESAMPLER_AUTO;
332 seconds = 60;
333
334 while ((c = getopt_long(argc, argv, "hv", long_options, NULL)) != -1) {
335
336 switch (c) {
337 case 'h' :
338 help(argv[0]);
339 ret = 0;
340 goto quit;
341
342 case 'v':
343 pa_log_set_level(PA_LOG_DEBUG);
344 verbose = 1;
345 break;
346
347 case ARG_VERSION:
348 printf(_("%s %s\n"), argv[0], PACKAGE_VERSION);
349 ret = 0;
350 goto quit;
351
352 case ARG_DUMP_RESAMPLE_METHODS:
353 dump_resample_methods();
354 ret = 0;
355 goto quit;
356
357 case ARG_FROM_CHANNELS:
358 a.channels = (uint8_t) atoi(optarg);
359 break;
360
361 case ARG_FROM_SAMPLEFORMAT:
362 a.format = pa_parse_sample_format(optarg);
363 all_formats = FALSE;
364 break;
365
366 case ARG_FROM_SAMPLERATE:
367 a.rate = (uint32_t) atoi(optarg);
368 break;
369
370 case ARG_TO_CHANNELS:
371 b.channels = (uint8_t) atoi(optarg);
372 break;
373
374 case ARG_TO_SAMPLEFORMAT:
375 b.format = pa_parse_sample_format(optarg);
376 all_formats = FALSE;
377 break;
378
379 case ARG_TO_SAMPLERATE:
380 b.rate = (uint32_t) atoi(optarg);
381 break;
382
383 case ARG_SECONDS:
384 seconds = atoi(optarg);
385 break;
386
387 case ARG_RESAMPLE_METHOD:
388 if (*optarg == '\0' || pa_streq(optarg, "help")) {
389 dump_resample_methods();
390 ret = 0;
391 goto quit;
392 }
393 method = pa_parse_resample_method(optarg);
394 break;
395
396 default:
397 goto quit;
398 }
399 }
400
401 ret = 0;
402 pa_assert_se(pool = pa_mempool_new(FALSE, 0));
403
404 if (!all_formats) {
405
406 pa_resampler *resampler;
407 pa_memchunk i, j;
408 pa_usec_t ts;
409
410 if (verbose) {
411 printf(_("Compilation CFLAGS: %s\n"), PA_CFLAGS);
412 printf(_("=== %d seconds: %d Hz %d ch (%s) -> %d Hz %d ch (%s)\n"), seconds,
413 a.rate, a.channels, pa_sample_format_to_string(a.format),
414 b.rate, b.channels, pa_sample_format_to_string(b.format));
415 }
416
417 ts = pa_rtclock_now();
418 pa_assert_se(resampler = pa_resampler_new(pool, &a, NULL, &b, NULL, method, 0));
419 printf("init: %llu\n", (long long unsigned)(pa_rtclock_now() - ts));
420
421 i.memblock = pa_memblock_new(pool, pa_usec_to_bytes(1*PA_USEC_PER_SEC, &a));
422
423 ts = pa_rtclock_now();
424 i.length = pa_memblock_get_length(i.memblock);
425 i.index = 0;
426 while (seconds--) {
427 pa_resampler_run(resampler, &i, &j);
428 pa_memblock_unref(j.memblock);
429 }
430 printf("resampling: %llu\n", (long long unsigned)(pa_rtclock_now() - ts));
431 pa_memblock_unref(i.memblock);
432
433 pa_resampler_free(resampler);
434
435 goto quit;
436 }
437
438 for (a.format = 0; a.format < PA_SAMPLE_MAX; a.format ++) {
439 for (b.format = 0; b.format < PA_SAMPLE_MAX; b.format ++) {
440 pa_resampler *forth, *back;
441 pa_memchunk i, j, k;
442
443 if (verbose)
444 printf("=== %s -> %s -> %s -> /2\n",
445 pa_sample_format_to_string(a.format),
446 pa_sample_format_to_string(b.format),
447 pa_sample_format_to_string(a.format));
448
449 pa_assert_se(forth = pa_resampler_new(pool, &a, NULL, &b, NULL, method, 0));
450 pa_assert_se(back = pa_resampler_new(pool, &b, NULL, &a, NULL, method, 0));
451
452 i.memblock = generate_block(pool, &a);
453 i.length = pa_memblock_get_length(i.memblock);
454 i.index = 0;
455 pa_resampler_run(forth, &i, &j);
456 pa_resampler_run(back, &j, &k);
457
458 printf("before: ");
459 dump_block(&a, &i);
460 printf("after : ");
461 dump_block(&b, &j);
462 printf("reverse: ");
463 dump_block(&a, &k);
464
465 pa_memblock_unref(i.memblock);
466 pa_memblock_unref(j.memblock);
467 pa_memblock_unref(k.memblock);
468
469 pa_resampler_free(forth);
470 pa_resampler_free(back);
471 }
472 }
473
474 quit:
475 if (pool)
476 pa_mempool_free(pool);
477
478 return ret;
479 }