]> code.delx.au - pulseaudio/blob - src/pulsecore/resampler.c
delx.au / code / pulseaudio / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Get rid of liboil
[pulseaudio] / src / pulsecore / resampler.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2006 Lennart Poettering
5
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2.1 of the License,
9 or (at your option) any later version.
10
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public License
17 along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19 USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <string.h>
27
28 #ifdef HAVE_LIBSAMPLERATE
29 #include <samplerate.h>
30 #endif
31
32 #include <speex/speex_resampler.h>
33
34 #include <pulse/xmalloc.h>
35 #include <pulsecore/sconv.h>
36 #include <pulsecore/log.h>
37 #include <pulsecore/macro.h>
38 #include <pulsecore/strbuf.h>
39
40 #include "ffmpeg/avcodec.h"
41
42 #include "resampler.h"
43
44 /* Number of samples of extra space we allow the resamplers to return */
45 #define EXTRA_FRAMES 128
46
47 struct pa_resampler {
48 pa_resample_method_t method;
49 pa_resample_flags_t flags;
50
51 pa_sample_spec i_ss, o_ss;
52 pa_channel_map i_cm, o_cm;
53 size_t i_fz, o_fz, w_sz;
54 pa_mempool *mempool;
55
56 pa_memchunk buf1, buf2, buf3, buf4;
57 unsigned buf1_samples, buf2_samples, buf3_samples, buf4_samples;
58
59 pa_sample_format_t work_format;
60
61 pa_convert_func_t to_work_format_func;
62 pa_convert_func_t from_work_format_func;
63
64 float map_table[PA_CHANNELS_MAX][PA_CHANNELS_MAX];
65 pa_bool_t map_required;
66
67 void (*impl_free)(pa_resampler *r);
68 void (*impl_update_rates)(pa_resampler *r);
69 void (*impl_resample)(pa_resampler *r, const pa_memchunk *in, unsigned in_samples, pa_memchunk *out, unsigned *out_samples);
70 void (*impl_reset)(pa_resampler *r);
71
72 struct { /* data specific to the trivial resampler */
73 unsigned o_counter;
74 unsigned i_counter;
75 } trivial;
76
77 struct { /* data specific to the peak finder pseudo resampler */
78 unsigned o_counter;
79 unsigned i_counter;
80
81 float max_f[PA_CHANNELS_MAX];
82 int16_t max_i[PA_CHANNELS_MAX];
83
84 } peaks;
85
86 #ifdef HAVE_LIBSAMPLERATE
87 struct { /* data specific to libsamplerate */
88 SRC_STATE *state;
89 } src;
90 #endif
91
92 struct { /* data specific to speex */
93 SpeexResamplerState* state;
94 } speex;
95
96 struct { /* data specific to ffmpeg */
97 struct AVResampleContext *state;
98 pa_memchunk buf[PA_CHANNELS_MAX];
99 } ffmpeg;
100 };
101
102 static int copy_init(pa_resampler *r);
103 static int trivial_init(pa_resampler*r);
104 static int speex_init(pa_resampler*r);
105 static int ffmpeg_init(pa_resampler*r);
106 static int peaks_init(pa_resampler*r);
107 #ifdef HAVE_LIBSAMPLERATE
108 static int libsamplerate_init(pa_resampler*r);
109 #endif
110
111 static void calc_map_table(pa_resampler *r);
112
113 static int (* const init_table[])(pa_resampler*r) = {
114 #ifdef HAVE_LIBSAMPLERATE
115 [PA_RESAMPLER_SRC_SINC_BEST_QUALITY] = libsamplerate_init,
116 [PA_RESAMPLER_SRC_SINC_MEDIUM_QUALITY] = libsamplerate_init,
117 [PA_RESAMPLER_SRC_SINC_FASTEST] = libsamplerate_init,
118 [PA_RESAMPLER_SRC_ZERO_ORDER_HOLD] = libsamplerate_init,
119 [PA_RESAMPLER_SRC_LINEAR] = libsamplerate_init,
120 #else
121 [PA_RESAMPLER_SRC_SINC_BEST_QUALITY] = NULL,
122 [PA_RESAMPLER_SRC_SINC_MEDIUM_QUALITY] = NULL,
123 [PA_RESAMPLER_SRC_SINC_FASTEST] = NULL,
124 [PA_RESAMPLER_SRC_ZERO_ORDER_HOLD] = NULL,
125 [PA_RESAMPLER_SRC_LINEAR] = NULL,
126 #endif
127 [PA_RESAMPLER_TRIVIAL] = trivial_init,
128 [PA_RESAMPLER_SPEEX_FLOAT_BASE+0] = speex_init,
129 [PA_RESAMPLER_SPEEX_FLOAT_BASE+1] = speex_init,
130 [PA_RESAMPLER_SPEEX_FLOAT_BASE+2] = speex_init,
131 [PA_RESAMPLER_SPEEX_FLOAT_BASE+3] = speex_init,
132 [PA_RESAMPLER_SPEEX_FLOAT_BASE+4] = speex_init,
133 [PA_RESAMPLER_SPEEX_FLOAT_BASE+5] = speex_init,
134 [PA_RESAMPLER_SPEEX_FLOAT_BASE+6] = speex_init,
135 [PA_RESAMPLER_SPEEX_FLOAT_BASE+7] = speex_init,
136 [PA_RESAMPLER_SPEEX_FLOAT_BASE+8] = speex_init,
137 [PA_RESAMPLER_SPEEX_FLOAT_BASE+9] = speex_init,
138 [PA_RESAMPLER_SPEEX_FLOAT_BASE+10] = speex_init,
139 [PA_RESAMPLER_SPEEX_FIXED_BASE+0] = speex_init,
140 [PA_RESAMPLER_SPEEX_FIXED_BASE+1] = speex_init,
141 [PA_RESAMPLER_SPEEX_FIXED_BASE+2] = speex_init,
142 [PA_RESAMPLER_SPEEX_FIXED_BASE+3] = speex_init,
143 [PA_RESAMPLER_SPEEX_FIXED_BASE+4] = speex_init,
144 [PA_RESAMPLER_SPEEX_FIXED_BASE+5] = speex_init,
145 [PA_RESAMPLER_SPEEX_FIXED_BASE+6] = speex_init,
146 [PA_RESAMPLER_SPEEX_FIXED_BASE+7] = speex_init,
147 [PA_RESAMPLER_SPEEX_FIXED_BASE+8] = speex_init,
148 [PA_RESAMPLER_SPEEX_FIXED_BASE+9] = speex_init,
149 [PA_RESAMPLER_SPEEX_FIXED_BASE+10] = speex_init,
150 [PA_RESAMPLER_FFMPEG] = ffmpeg_init,
151 [PA_RESAMPLER_AUTO] = NULL,
152 [PA_RESAMPLER_COPY] = copy_init,
153 [PA_RESAMPLER_PEAKS] = peaks_init,
154 };
155
156 pa_resampler* pa_resampler_new(
157 pa_mempool *pool,
158 const pa_sample_spec *a,
159 const pa_channel_map *am,
160 const pa_sample_spec *b,
161 const pa_channel_map *bm,
162 pa_resample_method_t method,
163 pa_resample_flags_t flags) {
164
165 pa_resampler *r = NULL;
166
167 pa_assert(pool);
168 pa_assert(a);
169 pa_assert(b);
170 pa_assert(pa_sample_spec_valid(a));
171 pa_assert(pa_sample_spec_valid(b));
172 pa_assert(method >= 0);
173 pa_assert(method < PA_RESAMPLER_MAX);
174
175 /* Fix method */
176
177 if (!(flags & PA_RESAMPLER_VARIABLE_RATE) && a->rate == b->rate) {
178 pa_log_info("Forcing resampler 'copy', because of fixed, identical sample rates.");
179 method = PA_RESAMPLER_COPY;
180 }
181
182 if (!pa_resample_method_supported(method)) {
183 pa_log_warn("Support for resampler '%s' not compiled in, reverting to 'auto'.", pa_resample_method_to_string(method));
184 method = PA_RESAMPLER_AUTO;
185 }
186
187 if (method == PA_RESAMPLER_FFMPEG && (flags & PA_RESAMPLER_VARIABLE_RATE)) {
188 pa_log_info("Resampler 'ffmpeg' cannot do variable rate, reverting to resampler 'auto'.");
189 method = PA_RESAMPLER_AUTO;
190 }
191
192 if (method == PA_RESAMPLER_COPY && ((flags & PA_RESAMPLER_VARIABLE_RATE) || a->rate != b->rate)) {
193 pa_log_info("Resampler 'copy' cannot change sampling rate, reverting to resampler 'auto'.");
194 method = PA_RESAMPLER_AUTO;
195 }
196
197 if (method == PA_RESAMPLER_AUTO)
198 method = PA_RESAMPLER_SPEEX_FLOAT_BASE + 3;
199
200 r = pa_xnew(pa_resampler, 1);
201 r->mempool = pool;
202 r->method = method;
203 r->flags = flags;
204
205 r->impl_free = NULL;
206 r->impl_update_rates = NULL;
207 r->impl_resample = NULL;
208 r->impl_reset = NULL;
209
210 /* Fill sample specs */
211 r->i_ss = *a;
212 r->o_ss = *b;
213
214 if (am)
215 r->i_cm = *am;
216 else if (!pa_channel_map_init_auto(&r->i_cm, r->i_ss.channels, PA_CHANNEL_MAP_DEFAULT))
217 goto fail;
218
219 if (bm)
220 r->o_cm = *bm;
221 else if (!pa_channel_map_init_auto(&r->o_cm, r->o_ss.channels, PA_CHANNEL_MAP_DEFAULT))
222 goto fail;
223
224 r->i_fz = pa_frame_size(a);
225 r->o_fz = pa_frame_size(b);
226
227 pa_memchunk_reset(&r->buf1);
228 pa_memchunk_reset(&r->buf2);
229 pa_memchunk_reset(&r->buf3);
230 pa_memchunk_reset(&r->buf4);
231
232 r->buf1_samples = r->buf2_samples = r->buf3_samples = r->buf4_samples = 0;
233
234 calc_map_table(r);
235
236 pa_log_info("Using resampler '%s'", pa_resample_method_to_string(method));
237
238 if ((method >= PA_RESAMPLER_SPEEX_FIXED_BASE && method <= PA_RESAMPLER_SPEEX_FIXED_MAX) ||
239 (method == PA_RESAMPLER_FFMPEG))
240 r->work_format = PA_SAMPLE_S16NE;
241 else if (method == PA_RESAMPLER_TRIVIAL || method == PA_RESAMPLER_COPY || method == PA_RESAMPLER_PEAKS) {
242
243 if (r->map_required || a->format != b->format || method == PA_RESAMPLER_PEAKS) {
244
245 if (a->format == PA_SAMPLE_S32NE || a->format == PA_SAMPLE_S32RE ||
246 a->format == PA_SAMPLE_FLOAT32NE || a->format == PA_SAMPLE_FLOAT32RE ||
247 a->format == PA_SAMPLE_S24NE || a->format == PA_SAMPLE_S24RE ||
248 a->format == PA_SAMPLE_S24_32NE || a->format == PA_SAMPLE_S24_32RE ||
249 b->format == PA_SAMPLE_S32NE || b->format == PA_SAMPLE_S32RE ||
250 b->format == PA_SAMPLE_FLOAT32NE || b->format == PA_SAMPLE_FLOAT32RE ||
251 b->format == PA_SAMPLE_S24NE || b->format == PA_SAMPLE_S24RE ||
252 b->format == PA_SAMPLE_S24_32NE || b->format == PA_SAMPLE_S24_32RE)
253 r->work_format = PA_SAMPLE_FLOAT32NE;
254 else
255 r->work_format = PA_SAMPLE_S16NE;
256
257 } else
258 r->work_format = a->format;
259
260 } else
261 r->work_format = PA_SAMPLE_FLOAT32NE;
262
263 pa_log_info("Using %s as working format.", pa_sample_format_to_string(r->work_format));
264
265 r->w_sz = pa_sample_size_of_format(r->work_format);
266
267 if (r->i_ss.format == r->work_format)
268 r->to_work_format_func = NULL;
269 else if (r->work_format == PA_SAMPLE_FLOAT32NE) {
270 if (!(r->to_work_format_func = pa_get_convert_to_float32ne_function(r->i_ss.format)))
271 goto fail;
272 } else {
273 pa_assert(r->work_format == PA_SAMPLE_S16NE);
274 if (!(r->to_work_format_func = pa_get_convert_to_s16ne_function(r->i_ss.format)))
275 goto fail;
276 }
277
278 if (r->o_ss.format == r->work_format)
279 r->from_work_format_func = NULL;
280 else if (r->work_format == PA_SAMPLE_FLOAT32NE) {
281 if (!(r->from_work_format_func = pa_get_convert_from_float32ne_function(r->o_ss.format)))
282 goto fail;
283 } else {
284 pa_assert(r->work_format == PA_SAMPLE_S16NE);
285 if (!(r->from_work_format_func = pa_get_convert_from_s16ne_function(r->o_ss.format)))
286 goto fail;
287 }
288
289 /* initialize implementation */
290 if (init_table[method](r) < 0)
291 goto fail;
292
293 return r;
294
295 fail:
296 if (r)
297 pa_xfree(r);
298
299 return NULL;
300 }
301
302 void pa_resampler_free(pa_resampler *r) {
303 pa_assert(r);
304
305 if (r->impl_free)
306 r->impl_free(r);
307
308 if (r->buf1.memblock)
309 pa_memblock_unref(r->buf1.memblock);
310 if (r->buf2.memblock)
311 pa_memblock_unref(r->buf2.memblock);
312 if (r->buf3.memblock)
313 pa_memblock_unref(r->buf3.memblock);
314 if (r->buf4.memblock)
315 pa_memblock_unref(r->buf4.memblock);
316
317 pa_xfree(r);
318 }
319
320 void pa_resampler_set_input_rate(pa_resampler *r, uint32_t rate) {
321 pa_assert(r);
322 pa_assert(rate > 0);
323
324 if (r->i_ss.rate == rate)
325 return;
326
327 r->i_ss.rate = rate;
328
329 r->impl_update_rates(r);
330 }
331
332 void pa_resampler_set_output_rate(pa_resampler *r, uint32_t rate) {
333 pa_assert(r);
334 pa_assert(rate > 0);
335
336 if (r->o_ss.rate == rate)
337 return;
338
339 r->o_ss.rate = rate;
340
341 r->impl_update_rates(r);
342 }
343
344 size_t pa_resampler_request(pa_resampler *r, size_t out_length) {
345 pa_assert(r);
346
347 /* Let's round up here */
348
349 return (((((out_length + r->o_fz-1) / r->o_fz) * r->i_ss.rate) + r->o_ss.rate-1) / r->o_ss.rate) * r->i_fz;
350 }
351
352 size_t pa_resampler_result(pa_resampler *r, size_t in_length) {
353 pa_assert(r);
354
355 /* Let's round up here */
356
357 return (((((in_length + r->i_fz-1) / r->i_fz) * r->o_ss.rate) + r->i_ss.rate-1) / r->i_ss.rate) * r->o_fz;
358 }
359
360 size_t pa_resampler_max_block_size(pa_resampler *r) {
361 size_t block_size_max;
362 pa_sample_spec ss;
363 size_t fs;
364
365 pa_assert(r);
366
367 block_size_max = pa_mempool_block_size_max(r->mempool);
368
369 /* We deduce the "largest" sample spec we're using during the
370 * conversion */
371 ss.channels = (uint8_t) (PA_MAX(r->i_ss.channels, r->o_ss.channels));
372
373 /* We silently assume that the format enum is ordered by size */
374 ss.format = PA_MAX(r->i_ss.format, r->o_ss.format);
375 ss.format = PA_MAX(ss.format, r->work_format);
376
377 ss.rate = PA_MAX(r->i_ss.rate, r->o_ss.rate);
378
379 fs = pa_frame_size(&ss);
380
381 return (((block_size_max/fs - EXTRA_FRAMES)*r->i_ss.rate)/ss.rate)*r->i_fz;
382 }
383
384 void pa_resampler_reset(pa_resampler *r) {
385 pa_assert(r);
386
387 if (r->impl_reset)
388 r->impl_reset(r);
389 }
390
391 pa_resample_method_t pa_resampler_get_method(pa_resampler *r) {
392 pa_assert(r);
393
394 return r->method;
395 }
396
397 const pa_channel_map* pa_resampler_input_channel_map(pa_resampler *r) {
398 pa_assert(r);
399
400 return &r->i_cm;
401 }
402
403 const pa_sample_spec* pa_resampler_input_sample_spec(pa_resampler *r) {
404 pa_assert(r);
405
406 return &r->i_ss;
407 }
408
409 const pa_channel_map* pa_resampler_output_channel_map(pa_resampler *r) {
410 pa_assert(r);
411
412 return &r->o_cm;
413 }
414
415 const pa_sample_spec* pa_resampler_output_sample_spec(pa_resampler *r) {
416 pa_assert(r);
417
418 return &r->o_ss;
419 }
420
421 static const char * const resample_methods[] = {
422 "src-sinc-best-quality",
423 "src-sinc-medium-quality",
424 "src-sinc-fastest",
425 "src-zero-order-hold",
426 "src-linear",
427 "trivial",
428 "speex-float-0",
429 "speex-float-1",
430 "speex-float-2",
431 "speex-float-3",
432 "speex-float-4",
433 "speex-float-5",
434 "speex-float-6",
435 "speex-float-7",
436 "speex-float-8",
437 "speex-float-9",
438 "speex-float-10",
439 "speex-fixed-0",
440 "speex-fixed-1",
441 "speex-fixed-2",
442 "speex-fixed-3",
443 "speex-fixed-4",
444 "speex-fixed-5",
445 "speex-fixed-6",
446 "speex-fixed-7",
447 "speex-fixed-8",
448 "speex-fixed-9",
449 "speex-fixed-10",
450 "ffmpeg",
451 "auto",
452 "copy",
453 "peaks"
454 };
455
456 const char *pa_resample_method_to_string(pa_resample_method_t m) {
457
458 if (m < 0 || m >= PA_RESAMPLER_MAX)
459 return NULL;
460
461 return resample_methods[m];
462 }
463
464 int pa_resample_method_supported(pa_resample_method_t m) {
465
466 if (m < 0 || m >= PA_RESAMPLER_MAX)
467 return 0;
468
469 #ifndef HAVE_LIBSAMPLERATE
470 if (m <= PA_RESAMPLER_SRC_LINEAR)
471 return 0;
472 #endif
473
474 return 1;
475 }
476
477 pa_resample_method_t pa_parse_resample_method(const char *string) {
478 pa_resample_method_t m;
479
480 pa_assert(string);
481
482 for (m = 0; m < PA_RESAMPLER_MAX; m++)
483 if (!strcmp(string, resample_methods[m]))
484 return m;
485
486 if (!strcmp(string, "speex-fixed"))
487 return PA_RESAMPLER_SPEEX_FIXED_BASE + 3;
488
489 if (!strcmp(string, "speex-float"))
490 return PA_RESAMPLER_SPEEX_FLOAT_BASE + 3;
491
492 return PA_RESAMPLER_INVALID;
493 }
494
495 static pa_bool_t on_left(pa_channel_position_t p) {
496
497 return
498 p == PA_CHANNEL_POSITION_FRONT_LEFT ||
499 p == PA_CHANNEL_POSITION_REAR_LEFT ||
500 p == PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER ||
501 p == PA_CHANNEL_POSITION_SIDE_LEFT ||
502 p == PA_CHANNEL_POSITION_TOP_FRONT_LEFT ||
503 p == PA_CHANNEL_POSITION_TOP_REAR_LEFT;
504 }
505
506 static pa_bool_t on_right(pa_channel_position_t p) {
507
508 return
509 p == PA_CHANNEL_POSITION_FRONT_RIGHT ||
510 p == PA_CHANNEL_POSITION_REAR_RIGHT ||
511 p == PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER ||
512 p == PA_CHANNEL_POSITION_SIDE_RIGHT ||
513 p == PA_CHANNEL_POSITION_TOP_FRONT_RIGHT ||
514 p == PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
515 }
516
517 static pa_bool_t on_center(pa_channel_position_t p) {
518
519 return
520 p == PA_CHANNEL_POSITION_FRONT_CENTER ||
521 p == PA_CHANNEL_POSITION_REAR_CENTER ||
522 p == PA_CHANNEL_POSITION_TOP_CENTER ||
523 p == PA_CHANNEL_POSITION_TOP_FRONT_CENTER ||
524 p == PA_CHANNEL_POSITION_TOP_REAR_CENTER;
525 }
526
527 static pa_bool_t on_lfe(pa_channel_position_t p) {
528 return
529 p == PA_CHANNEL_POSITION_LFE;
530 }
531
532 static pa_bool_t on_front(pa_channel_position_t p) {
533 return
534 p == PA_CHANNEL_POSITION_FRONT_LEFT ||
535 p == PA_CHANNEL_POSITION_FRONT_RIGHT ||
536 p == PA_CHANNEL_POSITION_FRONT_CENTER ||
537 p == PA_CHANNEL_POSITION_TOP_FRONT_LEFT ||
538 p == PA_CHANNEL_POSITION_TOP_FRONT_RIGHT ||
539 p == PA_CHANNEL_POSITION_TOP_FRONT_CENTER ||
540 p == PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER ||
541 p == PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
542 }
543
544 static pa_bool_t on_rear(pa_channel_position_t p) {
545 return
546 p == PA_CHANNEL_POSITION_REAR_LEFT ||
547 p == PA_CHANNEL_POSITION_REAR_RIGHT ||
548 p == PA_CHANNEL_POSITION_REAR_CENTER ||
549 p == PA_CHANNEL_POSITION_TOP_REAR_LEFT ||
550 p == PA_CHANNEL_POSITION_TOP_REAR_RIGHT ||
551 p == PA_CHANNEL_POSITION_TOP_REAR_CENTER;
552 }
553
554 static pa_bool_t on_side(pa_channel_position_t p) {
555 return
556 p == PA_CHANNEL_POSITION_SIDE_LEFT ||
557 p == PA_CHANNEL_POSITION_SIDE_RIGHT ||
558 p == PA_CHANNEL_POSITION_TOP_CENTER;
559 }
560
561 enum {
562 ON_FRONT,
563 ON_REAR,
564 ON_SIDE,
565 ON_OTHER
566 };
567
568 static int front_rear_side(pa_channel_position_t p) {
569 if (on_front(p))
570 return ON_FRONT;
571 if (on_rear(p))
572 return ON_REAR;
573 if (on_side(p))
574 return ON_SIDE;
575 return ON_OTHER;
576 }
577
578 static void calc_map_table(pa_resampler *r) {
579 unsigned oc, ic;
580 pa_bool_t ic_connected[PA_CHANNELS_MAX];
581 pa_bool_t remix;
582 pa_strbuf *s;
583 char *t;
584
585 pa_assert(r);
586
587 if (!(r->map_required = (r->i_ss.channels != r->o_ss.channels || (!(r->flags & PA_RESAMPLER_NO_REMAP) && !pa_channel_map_equal(&r->i_cm, &r->o_cm)))))
588 return;
589
590 memset(r->map_table, 0, sizeof(r->map_table));
591 memset(ic_connected, 0, sizeof(ic_connected));
592 remix = (r->flags & (PA_RESAMPLER_NO_REMAP|PA_RESAMPLER_NO_REMIX)) == 0;
593
594 for (oc = 0; oc < r->o_ss.channels; oc++) {
595 pa_bool_t oc_connected = FALSE;
596 pa_channel_position_t b = r->o_cm.map[oc];
597
598 for (ic = 0; ic < r->i_ss.channels; ic++) {
599 pa_channel_position_t a = r->i_cm.map[ic];
600
601 if (r->flags & PA_RESAMPLER_NO_REMAP) {
602 /* We shall not do any remapping. Hence, just check by index */
603
604 if (ic == oc)
605 r->map_table[oc][ic] = 1.0;
606
607 continue;
608 }
609
610 if (r->flags & PA_RESAMPLER_NO_REMIX) {
611 /* We shall not do any remixing. Hence, just check by name */
612
613 if (a == b)
614 r->map_table[oc][ic] = 1.0;
615
616 continue;
617 }
618
619 pa_assert(remix);
620
621 /* OK, we shall do the full monty: upmixing and
622 * downmixing. Our algorithm is relatively simple, does
623 * not do spacialization, delay elements or apply lowpass
624 * filters for LFE. Patches are always welcome,
625 * though. Oh, and it doesn't do any matrix
626 * decoding. (Which probably wouldn't make any sense
627 * anyway.)
628 *
629 * This code is not idempotent: downmixing an upmixed
630 * stereo stream is not identical to the original. The
631 * volume will not match, and the two channels will be a
632 * linear combination of both.
633 *
634 * This is losely based on random suggestions found on the
635 * Internet, such as this:
636 * http://www.halfgaar.net/surround-sound-in-linux and the
637 * alsa upmix plugin.
638 *
639 * The algorithm works basically like this:
640 *
641 * 1) Connect all channels with matching names.
642 *
643 * 2) Mono Handling:
644 * S:Mono: Copy into all D:channels
645 * D:Mono: Copy in all S:channels
646 *
647 * 3) Mix D:Left, D:Right:
648 * D:Left: If not connected, avg all S:Left
649 * D:Right: If not connected, avg all S:Right
650 *
651 * 4) Mix D:Center
652 * If not connected, avg all S:Center
653 * If still not connected, avg all S:Left, S:Right
654 *
655 * 5) Mix D:LFE
656 * If not connected, avg all S:*
657 *
658 * 6) Make sure S:Left/S:Right is used: S:Left/S:Right: If
659 * not connected, mix into all D:left and all D:right
660 * channels. Gain is 0.1, the current left and right
661 * should be multiplied by 0.9.
662 *
663 * 7) Make sure S:Center, S:LFE is used:
664 *
665 * S:Center, S:LFE: If not connected, mix into all
666 * D:left, all D:right, all D:center channels, gain is
667 * 0.375. The current (as result of 1..6) factors
668 * should be multiplied by 0.75. (Alt. suggestion: 0.25
669 * vs. 0.5) If C-front is only mixed into
670 * L-front/R-front if available, otherwise into all L/R
671 * channels. Similarly for C-rear.
672 *
673 * S: and D: shall relate to the source resp. destination channels.
674 *
675 * Rationale: 1, 2 are probably obvious. For 3: this
676 * copies front to rear if needed. For 4: we try to find
677 * some suitable C source for C, if we don't find any, we
678 * avg L and R. For 5: LFE is mixed from all channels. For
679 * 6: the rear channels should not be dropped entirely,
680 * however have only minimal impact. For 7: movies usually
681 * encode speech on the center channel. Thus we have to
682 * make sure this channel is distributed to L and R if not
683 * available in the output. Also, LFE is used to achieve a
684 * greater dynamic range, and thus we should try to do our
685 * best to pass it to L+R.
686 */
687
688 if (a == b || a == PA_CHANNEL_POSITION_MONO || b == PA_CHANNEL_POSITION_MONO) {
689 r->map_table[oc][ic] = 1.0;
690
691 oc_connected = TRUE;
692 ic_connected[ic] = TRUE;
693 }
694 }
695
696 if (!oc_connected && remix) {
697 /* OK, we shall remix */
698
699 /* Try to find matching input ports for this output port */
700
701 if (on_left(b)) {
702 unsigned n = 0;
703
704 /* We are not connected and on the left side, let's
705 * average all left side input channels. */
706
707 for (ic = 0; ic < r->i_ss.channels; ic++)
708 if (on_left(r->i_cm.map[ic]))
709 n++;
710
711 if (n > 0)
712 for (ic = 0; ic < r->i_ss.channels; ic++)
713 if (on_left(r->i_cm.map[ic])) {
714 r->map_table[oc][ic] = 1.0f / (float) n;
715 ic_connected[ic] = TRUE;
716 }
717
718 /* We ignore the case where there is no left input
719 * channel. Something is really wrong in this case
720 * anyway. */
721
722 } else if (on_right(b)) {
723 unsigned n = 0;
724
725 /* We are not connected and on the right side, let's
726 * average all right side input channels. */
727
728 for (ic = 0; ic < r->i_ss.channels; ic++)
729 if (on_right(r->i_cm.map[ic]))
730 n++;
731
732 if (n > 0)
733 for (ic = 0; ic < r->i_ss.channels; ic++)
734 if (on_right(r->i_cm.map[ic])) {
735 r->map_table[oc][ic] = 1.0f / (float) n;
736 ic_connected[ic] = TRUE;
737 }
738
739 /* We ignore the case where there is no right input
740 * channel. Something is really wrong in this case
741 * anyway. */
742
743 } else if (on_center(b)) {
744 unsigned n = 0;
745
746 /* We are not connected and at the center. Let's
747 * average all center input channels. */
748
749 for (ic = 0; ic < r->i_ss.channels; ic++)
750 if (on_center(r->i_cm.map[ic]))
751 n++;
752
753 if (n > 0) {
754 for (ic = 0; ic < r->i_ss.channels; ic++)
755 if (on_center(r->i_cm.map[ic])) {
756 r->map_table[oc][ic] = 1.0f / (float) n;
757 ic_connected[ic] = TRUE;
758 }
759 } else {
760
761 /* Hmm, no center channel around, let's synthesize
762 * it by mixing L and R.*/
763
764 n = 0;
765
766 for (ic = 0; ic < r->i_ss.channels; ic++)
767 if (on_left(r->i_cm.map[ic]) || on_right(r->i_cm.map[ic]))
768 n++;
769
770 if (n > 0)
771 for (ic = 0; ic < r->i_ss.channels; ic++)
772 if (on_left(r->i_cm.map[ic]) || on_right(r->i_cm.map[ic])) {
773 r->map_table[oc][ic] = 1.0f / (float) n;
774 ic_connected[ic] = TRUE;
775 }
776
777 /* We ignore the case where there is not even a
778 * left or right input channel. Something is
779 * really wrong in this case anyway. */
780 }
781
782 } else if (on_lfe(b)) {
783
784 /* We are not connected and an LFE. Let's average all
785 * channels for LFE. */
786
787 for (ic = 0; ic < r->i_ss.channels; ic++) {
788
789 if (!(r->flags & PA_RESAMPLER_NO_LFE))
790 r->map_table[oc][ic] = 1.0f / (float) r->i_ss.channels;
791 else
792 r->map_table[oc][ic] = 0;
793
794 /* Please note that a channel connected to LFE
795 * doesn't really count as connected. */
796 }
797 }
798 }
799 }
800
801 if (remix) {
802 unsigned
803 ic_unconnected_left = 0,
804 ic_unconnected_right = 0,
805 ic_unconnected_center = 0,
806 ic_unconnected_lfe = 0;
807
808 for (ic = 0; ic < r->i_ss.channels; ic++) {
809 pa_channel_position_t a = r->i_cm.map[ic];
810
811 if (ic_connected[ic])
812 continue;
813
814 if (on_left(a))
815 ic_unconnected_left++;
816 else if (on_right(a))
817 ic_unconnected_right++;
818 else if (on_center(a))
819 ic_unconnected_center++;
820 else if (on_lfe(a))
821 ic_unconnected_lfe++;
822 }
823
824 if (ic_unconnected_left > 0) {
825
826 /* OK, so there are unconnected input channels on the
827 * left. Let's multiply all already connected channels on
828 * the left side by .9 and add in our averaged unconnected
829 * channels multplied by .1 */
830
831 for (oc = 0; oc < r->o_ss.channels; oc++) {
832
833 if (!on_left(r->o_cm.map[oc]))
834 continue;
835
836 for (ic = 0; ic < r->i_ss.channels; ic++) {
837
838 if (ic_connected[ic]) {
839 r->map_table[oc][ic] *= .9f;
840 continue;
841 }
842
843 if (on_left(r->i_cm.map[ic]))
844 r->map_table[oc][ic] = .1f / (float) ic_unconnected_left;
845 }
846 }
847 }
848
849 if (ic_unconnected_right > 0) {
850
851 /* OK, so there are unconnected input channels on the
852 * right. Let's multiply all already connected channels on
853 * the right side by .9 and add in our averaged unconnected
854 * channels multplied by .1 */
855
856 for (oc = 0; oc < r->o_ss.channels; oc++) {
857
858 if (!on_right(r->o_cm.map[oc]))
859 continue;
860
861 for (ic = 0; ic < r->i_ss.channels; ic++) {
862
863 if (ic_connected[ic]) {
864 r->map_table[oc][ic] *= .9f;
865 continue;
866 }
867
868 if (on_right(r->i_cm.map[ic]))
869 r->map_table[oc][ic] = .1f / (float) ic_unconnected_right;
870 }
871 }
872 }
873
874 if (ic_unconnected_center > 0) {
875 pa_bool_t mixed_in = FALSE;
876
877 /* OK, so there are unconnected input channels on the
878 * center. Let's multiply all already connected channels on
879 * the center side by .9 and add in our averaged unconnected
880 * channels multplied by .1 */
881
882 for (oc = 0; oc < r->o_ss.channels; oc++) {
883
884 if (!on_center(r->o_cm.map[oc]))
885 continue;
886
887 for (ic = 0; ic < r->i_ss.channels; ic++) {
888
889 if (ic_connected[ic]) {
890 r->map_table[oc][ic] *= .9f;
891 continue;
892 }
893
894 if (on_center(r->i_cm.map[ic])) {
895 r->map_table[oc][ic] = .1f / (float) ic_unconnected_center;
896 mixed_in = TRUE;
897 }
898 }
899 }
900
901 if (!mixed_in) {
902 unsigned ncenter[PA_CHANNELS_MAX];
903 pa_bool_t found_frs[PA_CHANNELS_MAX];
904
905 memset(ncenter, 0, sizeof(ncenter));
906 memset(found_frs, 0, sizeof(found_frs));
907
908 /* Hmm, as it appears there was no center channel we
909 could mix our center channel in. In this case, mix
910 it into left and right. Using .375 and 0.75 as
911 factors. */
912
913 for (ic = 0; ic < r->i_ss.channels; ic++) {
914
915 if (ic_connected[ic])
916 continue;
917
918 if (!on_center(r->i_cm.map[ic]))
919 continue;
920
921 for (oc = 0; oc < r->o_ss.channels; oc++) {
922
923 if (!on_left(r->o_cm.map[oc]) && !on_right(r->o_cm.map[oc]))
924 continue;
925
926 if (front_rear_side(r->i_cm.map[ic]) == front_rear_side(r->o_cm.map[oc])) {
927 found_frs[ic] = TRUE;
928 break;
929 }
930 }
931
932 for (oc = 0; oc < r->o_ss.channels; oc++) {
933
934 if (!on_left(r->o_cm.map[oc]) && !on_right(r->o_cm.map[oc]))
935 continue;
936
937 if (!found_frs[ic] || front_rear_side(r->i_cm.map[ic]) == front_rear_side(r->o_cm.map[oc]))
938 ncenter[oc]++;
939 }
940 }
941
942 for (oc = 0; oc < r->o_ss.channels; oc++) {
943
944 if (!on_left(r->o_cm.map[oc]) && !on_right(r->o_cm.map[oc]))
945 continue;
946
947 if (ncenter[oc] <= 0)
948 continue;
949
950 for (ic = 0; ic < r->i_ss.channels; ic++) {
951
952 if (ic_connected[ic]) {
953 r->map_table[oc][ic] *= .75f;
954 continue;
955 }
956
957 if (!on_center(r->i_cm.map[ic]))
958 continue;
959
960 if (!found_frs[ic] || front_rear_side(r->i_cm.map[ic]) == front_rear_side(r->o_cm.map[oc]))
961 r->map_table[oc][ic] = .375f / (float) ncenter[oc];
962 }
963 }
964 }
965 }
966
967 if (ic_unconnected_lfe > 0 && !(r->flags & PA_RESAMPLER_NO_LFE)) {
968
969 /* OK, so there is an unconnected LFE channel. Let's mix
970 * it into all channels, with factor 0.375 */
971
972 for (ic = 0; ic < r->i_ss.channels; ic++) {
973
974 if (!on_lfe(r->i_cm.map[ic]))
975 continue;
976
977 for (oc = 0; oc < r->o_ss.channels; oc++)
978 r->map_table[oc][ic] = 0.375f / (float) ic_unconnected_lfe;
979 }
980 }
981 }
982
983
984 s = pa_strbuf_new();
985
986 pa_strbuf_printf(s, " ");
987 for (ic = 0; ic < r->i_ss.channels; ic++)
988 pa_strbuf_printf(s, " I%02u ", ic);
989 pa_strbuf_puts(s, "\n +");
990
991 for (ic = 0; ic < r->i_ss.channels; ic++)
992 pa_strbuf_printf(s, "------");
993 pa_strbuf_puts(s, "\n");
994
995 for (oc = 0; oc < r->o_ss.channels; oc++) {
996 pa_strbuf_printf(s, "O%02u |", oc);
997
998 for (ic = 0; ic < r->i_ss.channels; ic++)
999 pa_strbuf_printf(s, " %1.3f", r->map_table[oc][ic]);
1000
1001 pa_strbuf_puts(s, "\n");
1002 }
1003
1004 pa_log_debug("Channel matrix:\n%s", t = pa_strbuf_tostring_free(s));
1005 pa_xfree(t);
1006 }
1007
1008 static pa_memchunk* convert_to_work_format(pa_resampler *r, pa_memchunk *input) {
1009 unsigned n_samples;
1010 void *src, *dst;
1011
1012 pa_assert(r);
1013 pa_assert(input);
1014 pa_assert(input->memblock);
1015
1016 /* Convert the incoming sample into the work sample format and place them in buf1 */
1017
1018 if (!r->to_work_format_func || !input->length)
1019 return input;
1020
1021 n_samples = (unsigned) ((input->length / r->i_fz) * r->i_ss.channels);
1022
1023 r->buf1.index = 0;
1024 r->buf1.length = r->w_sz * n_samples;
1025
1026 if (!r->buf1.memblock || r->buf1_samples < n_samples) {
1027 if (r->buf1.memblock)
1028 pa_memblock_unref(r->buf1.memblock);
1029
1030 r->buf1_samples = n_samples;
1031 r->buf1.memblock = pa_memblock_new(r->mempool, r->buf1.length);
1032 }
1033
1034 src = (uint8_t*) pa_memblock_acquire(input->memblock) + input->index;
1035 dst = (uint8_t*) pa_memblock_acquire(r->buf1.memblock);
1036
1037 r->to_work_format_func(n_samples, src, dst);
1038
1039 pa_memblock_release(input->memblock);
1040 pa_memblock_release(r->buf1.memblock);
1041
1042 return &r->buf1;
1043 }
1044
1045 static void vectoradd_f32(
1046 float *d, int dstr,
1047 const float *s, int sstr,
1048 int n, float s4) {
1049
1050 for (; n > 0; n--) {
1051 *d = (float) (*d + (s4 * *s));
1052
1053 s = (const float*) ((const uint8_t*) s + sstr);
1054 d = (float*) ((uint8_t*) d + dstr);
1055 }
1056 }
1057
1058 static void vectoradd_s16(
1059 int16_t *d, int dstr,
1060 const int16_t *s, int sstr,
1061 int n) {
1062
1063 for (; n > 0; n--) {
1064 *d = (int16_t) (*d + *s);
1065
1066 s = (const int16_t*) ((const uint8_t*) s + sstr);
1067 d = (int16_t*) ((uint8_t*) d + dstr);
1068 }
1069 }
1070
1071 static void vectoradd_s16_with_fraction(
1072 int16_t *d, int dstr,
1073 const int16_t *s, int sstr,
1074 int n, float s4) {
1075
1076 int32_t i4;
1077
1078 i4 = (int32_t) (s4 * 0x10000);
1079
1080 for (; n > 0; n--) {
1081 *d = (int16_t) (*d + (((int32_t)*s * i4) >> 16));
1082
1083 s = (const int16_t*) ((const uint8_t*) s + sstr);
1084 d = (int16_t*) ((uint8_t*) d + dstr);
1085 }
1086 }
1087
1088 static pa_memchunk *remap_channels(pa_resampler *r, pa_memchunk *input) {
1089 unsigned in_n_samples, out_n_samples, n_frames;
1090 int i_skip, o_skip;
1091 unsigned oc;
1092 void *src, *dst;
1093
1094 pa_assert(r);
1095 pa_assert(input);
1096 pa_assert(input->memblock);
1097
1098 /* Remap channels and place the result int buf2 */
1099
1100 if (!r->map_required || !input->length)
1101 return input;
1102
1103 in_n_samples = (unsigned) (input->length / r->w_sz);
1104 n_frames = in_n_samples / r->i_ss.channels;
1105 out_n_samples = n_frames * r->o_ss.channels;
1106
1107 r->buf2.index = 0;
1108 r->buf2.length = r->w_sz * out_n_samples;
1109
1110 if (!r->buf2.memblock || r->buf2_samples < out_n_samples) {
1111 if (r->buf2.memblock)
1112 pa_memblock_unref(r->buf2.memblock);
1113
1114 r->buf2_samples = out_n_samples;
1115 r->buf2.memblock = pa_memblock_new(r->mempool, r->buf2.length);
1116 }
1117
1118 src = ((uint8_t*) pa_memblock_acquire(input->memblock) + input->index);
1119 dst = pa_memblock_acquire(r->buf2.memblock);
1120
1121 memset(dst, 0, r->buf2.length);
1122
1123 o_skip = (int) (r->w_sz * r->o_ss.channels);
1124 i_skip = (int) (r->w_sz * r->i_ss.channels);
1125
1126 switch (r->work_format) {
1127 case PA_SAMPLE_FLOAT32NE:
1128
1129 for (oc = 0; oc < r->o_ss.channels; oc++) {
1130 unsigned ic;
1131 static const float one = 1.0;
1132
1133 for (ic = 0; ic < r->i_ss.channels; ic++) {
1134
1135 if (r->map_table[oc][ic] <= 0.0)
1136 continue;
1137
1138 vectoradd_f32(
1139 (float*) dst + oc, o_skip,
1140 (float*) src + ic, i_skip,
1141 (int) n_frames,
1142 r->map_table[oc][ic]);
1143 }
1144 }
1145
1146 break;
1147
1148 case PA_SAMPLE_S16NE:
1149
1150 for (oc = 0; oc < r->o_ss.channels; oc++) {
1151 unsigned ic;
1152
1153 for (ic = 0; ic < r->i_ss.channels; ic++) {
1154
1155 if (r->map_table[oc][ic] <= 0.0)
1156 continue;
1157
1158 if (r->map_table[oc][ic] >= 1.0) {
1159
1160 vectoradd_s16(
1161 (int16_t*) dst + oc, o_skip,
1162 (int16_t*) src + ic, i_skip,
1163 (int) n_frames);
1164
1165 } else
1166
1167 vectoradd_s16_with_fraction(
1168 (int16_t*) dst + oc, o_skip,
1169 (int16_t*) src + ic, i_skip,
1170 (int) n_frames,
1171 r->map_table[oc][ic]);
1172 }
1173 }
1174
1175 break;
1176
1177 default:
1178 pa_assert_not_reached();
1179 }
1180
1181 pa_memblock_release(input->memblock);
1182 pa_memblock_release(r->buf2.memblock);
1183
1184 r->buf2.length = out_n_samples * r->w_sz;
1185
1186 return &r->buf2;
1187 }
1188
1189 static pa_memchunk *resample(pa_resampler *r, pa_memchunk *input) {
1190 unsigned in_n_frames, in_n_samples;
1191 unsigned out_n_frames, out_n_samples;
1192
1193 pa_assert(r);
1194 pa_assert(input);
1195
1196 /* Resample the data and place the result in buf3 */
1197
1198 if (!r->impl_resample || !input->length)
1199 return input;
1200
1201 in_n_samples = (unsigned) (input->length / r->w_sz);
1202 in_n_frames = (unsigned) (in_n_samples / r->o_ss.channels);
1203
1204 out_n_frames = ((in_n_frames*r->o_ss.rate)/r->i_ss.rate)+EXTRA_FRAMES;
1205 out_n_samples = out_n_frames * r->o_ss.channels;
1206
1207 r->buf3.index = 0;
1208 r->buf3.length = r->w_sz * out_n_samples;
1209
1210 if (!r->buf3.memblock || r->buf3_samples < out_n_samples) {
1211 if (r->buf3.memblock)
1212 pa_memblock_unref(r->buf3.memblock);
1213
1214 r->buf3_samples = out_n_samples;
1215 r->buf3.memblock = pa_memblock_new(r->mempool, r->buf3.length);
1216 }
1217
1218 r->impl_resample(r, input, in_n_frames, &r->buf3, &out_n_frames);
1219 r->buf3.length = out_n_frames * r->w_sz * r->o_ss.channels;
1220
1221 return &r->buf3;
1222 }
1223
1224 static pa_memchunk *convert_from_work_format(pa_resampler *r, pa_memchunk *input) {
1225 unsigned n_samples, n_frames;
1226 void *src, *dst;
1227
1228 pa_assert(r);
1229 pa_assert(input);
1230
1231 /* Convert the data into the correct sample type and place the result in buf4 */
1232
1233 if (!r->from_work_format_func || !input->length)
1234 return input;
1235
1236 n_samples = (unsigned) (input->length / r->w_sz);
1237 n_frames = n_samples / r->o_ss.channels;
1238
1239 r->buf4.index = 0;
1240 r->buf4.length = r->o_fz * n_frames;
1241
1242 if (!r->buf4.memblock || r->buf4_samples < n_samples) {
1243 if (r->buf4.memblock)
1244 pa_memblock_unref(r->buf4.memblock);
1245
1246 r->buf4_samples = n_samples;
1247 r->buf4.memblock = pa_memblock_new(r->mempool, r->buf4.length);
1248 }
1249
1250 src = (uint8_t*) pa_memblock_acquire(input->memblock) + input->index;
1251 dst = pa_memblock_acquire(r->buf4.memblock);
1252 r->from_work_format_func(n_samples, src, dst);
1253 pa_memblock_release(input->memblock);
1254 pa_memblock_release(r->buf4.memblock);
1255
1256 r->buf4.length = r->o_fz * n_frames;
1257
1258 return &r->buf4;
1259 }
1260
1261 void pa_resampler_run(pa_resampler *r, const pa_memchunk *in, pa_memchunk *out) {
1262 pa_memchunk *buf;
1263
1264 pa_assert(r);
1265 pa_assert(in);
1266 pa_assert(out);
1267 pa_assert(in->length);
1268 pa_assert(in->memblock);
1269 pa_assert(in->length % r->i_fz == 0);
1270
1271 buf = (pa_memchunk*) in;
1272 buf = convert_to_work_format(r, buf);
1273 buf = remap_channels(r, buf);
1274 buf = resample(r, buf);
1275
1276 if (buf->length) {
1277 buf = convert_from_work_format(r, buf);
1278 *out = *buf;
1279
1280 if (buf == in)
1281 pa_memblock_ref(buf->memblock);
1282 else
1283 pa_memchunk_reset(buf);
1284 } else
1285 pa_memchunk_reset(out);
1286 }
1287
1288 /*** libsamplerate based implementation ***/
1289
1290 #ifdef HAVE_LIBSAMPLERATE
1291 static void libsamplerate_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
1292 SRC_DATA data;
1293
1294 pa_assert(r);
1295 pa_assert(input);
1296 pa_assert(output);
1297 pa_assert(out_n_frames);
1298
1299 memset(&data, 0, sizeof(data));
1300
1301 data.data_in = (float*) ((uint8_t*) pa_memblock_acquire(input->memblock) + input->index);
1302 data.input_frames = (long int) in_n_frames;
1303
1304 data.data_out = (float*) ((uint8_t*) pa_memblock_acquire(output->memblock) + output->index);
1305 data.output_frames = (long int) *out_n_frames;
1306
1307 data.src_ratio = (double) r->o_ss.rate / r->i_ss.rate;
1308 data.end_of_input = 0;
1309
1310 pa_assert_se(src_process(r->src.state, &data) == 0);
1311 pa_assert((unsigned) data.input_frames_used == in_n_frames);
1312
1313 pa_memblock_release(input->memblock);
1314 pa_memblock_release(output->memblock);
1315
1316 *out_n_frames = (unsigned) data.output_frames_gen;
1317 }
1318
1319 static void libsamplerate_update_rates(pa_resampler *r) {
1320 pa_assert(r);
1321
1322 pa_assert_se(src_set_ratio(r->src.state, (double) r->o_ss.rate / r->i_ss.rate) == 0);
1323 }
1324
1325 static void libsamplerate_reset(pa_resampler *r) {
1326 pa_assert(r);
1327
1328 pa_assert_se(src_reset(r->src.state) == 0);
1329 }
1330
1331 static void libsamplerate_free(pa_resampler *r) {
1332 pa_assert(r);
1333
1334 if (r->src.state)
1335 src_delete(r->src.state);
1336 }
1337
1338 static int libsamplerate_init(pa_resampler *r) {
1339 int err;
1340
1341 pa_assert(r);
1342
1343 if (!(r->src.state = src_new(r->method, r->o_ss.channels, &err)))
1344 return -1;
1345
1346 r->impl_free = libsamplerate_free;
1347 r->impl_update_rates = libsamplerate_update_rates;
1348 r->impl_resample = libsamplerate_resample;
1349 r->impl_reset = libsamplerate_reset;
1350
1351 return 0;
1352 }
1353 #endif
1354
1355 /*** speex based implementation ***/
1356
1357 static void speex_resample_float(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
1358 float *in, *out;
1359 uint32_t inf = in_n_frames, outf = *out_n_frames;
1360
1361 pa_assert(r);
1362 pa_assert(input);
1363 pa_assert(output);
1364 pa_assert(out_n_frames);
1365
1366 in = (float*) ((uint8_t*) pa_memblock_acquire(input->memblock) + input->index);
1367 out = (float*) ((uint8_t*) pa_memblock_acquire(output->memblock) + output->index);
1368
1369 pa_assert_se(speex_resampler_process_interleaved_float(r->speex.state, in, &inf, out, &outf) == 0);
1370
1371 pa_memblock_release(input->memblock);
1372 pa_memblock_release(output->memblock);
1373
1374 pa_assert(inf == in_n_frames);
1375 *out_n_frames = outf;
1376 }
1377
1378 static void speex_resample_int(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
1379 int16_t *in, *out;
1380 uint32_t inf = in_n_frames, outf = *out_n_frames;
1381
1382 pa_assert(r);
1383 pa_assert(input);
1384 pa_assert(output);
1385 pa_assert(out_n_frames);
1386
1387 in = (int16_t*) ((uint8_t*) pa_memblock_acquire(input->memblock) + input->index);
1388 out = (int16_t*) ((uint8_t*) pa_memblock_acquire(output->memblock) + output->index);
1389
1390 pa_assert_se(speex_resampler_process_interleaved_int(r->speex.state, in, &inf, out, &outf) == 0);
1391
1392 pa_memblock_release(input->memblock);
1393 pa_memblock_release(output->memblock);
1394
1395 pa_assert(inf == in_n_frames);
1396 *out_n_frames = outf;
1397 }
1398
1399 static void speex_update_rates(pa_resampler *r) {
1400 pa_assert(r);
1401
1402 pa_assert_se(speex_resampler_set_rate(r->speex.state, r->i_ss.rate, r->o_ss.rate) == 0);
1403 }
1404
1405 static void speex_reset(pa_resampler *r) {
1406 pa_assert(r);
1407
1408 pa_assert_se(speex_resampler_reset_mem(r->speex.state) == 0);
1409 }
1410
1411 static void speex_free(pa_resampler *r) {
1412 pa_assert(r);
1413
1414 if (!r->speex.state)
1415 return;
1416
1417 speex_resampler_destroy(r->speex.state);
1418 }
1419
1420 static int speex_init(pa_resampler *r) {
1421 int q, err;
1422
1423 pa_assert(r);
1424
1425 r->impl_free = speex_free;
1426 r->impl_update_rates = speex_update_rates;
1427 r->impl_reset = speex_reset;
1428
1429 if (r->method >= PA_RESAMPLER_SPEEX_FIXED_BASE && r->method <= PA_RESAMPLER_SPEEX_FIXED_MAX) {
1430
1431 q = r->method - PA_RESAMPLER_SPEEX_FIXED_BASE;
1432 r->impl_resample = speex_resample_int;
1433
1434 } else {
1435 pa_assert(r->method >= PA_RESAMPLER_SPEEX_FLOAT_BASE && r->method <= PA_RESAMPLER_SPEEX_FLOAT_MAX);
1436
1437 q = r->method - PA_RESAMPLER_SPEEX_FLOAT_BASE;
1438 r->impl_resample = speex_resample_float;
1439 }
1440
1441 pa_log_info("Choosing speex quality setting %i.", q);
1442
1443 if (!(r->speex.state = speex_resampler_init(r->o_ss.channels, r->i_ss.rate, r->o_ss.rate, q, &err)))
1444 return -1;
1445
1446 return 0;
1447 }
1448
1449 /* Trivial implementation */
1450
1451 static void trivial_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
1452 size_t fz;
1453 unsigned o_index;
1454 void *src, *dst;
1455
1456 pa_assert(r);
1457 pa_assert(input);
1458 pa_assert(output);
1459 pa_assert(out_n_frames);
1460
1461 fz = r->w_sz * r->o_ss.channels;
1462
1463 src = (uint8_t*) pa_memblock_acquire(input->memblock) + input->index;
1464 dst = (uint8_t*) pa_memblock_acquire(output->memblock) + output->index;
1465
1466 for (o_index = 0;; o_index++, r->trivial.o_counter++) {
1467 unsigned j;
1468
1469 j = ((r->trivial.o_counter * r->i_ss.rate) / r->o_ss.rate);
1470 j = j > r->trivial.i_counter ? j - r->trivial.i_counter : 0;
1471
1472 if (j >= in_n_frames)
1473 break;
1474
1475 pa_assert(o_index * fz < pa_memblock_get_length(output->memblock));
1476
1477 memcpy((uint8_t*) dst + fz * o_index,
1478 (uint8_t*) src + fz * j, (int) fz);
1479 }
1480
1481 pa_memblock_release(input->memblock);
1482 pa_memblock_release(output->memblock);
1483
1484 *out_n_frames = o_index;
1485
1486 r->trivial.i_counter += in_n_frames;
1487
1488 /* Normalize counters */
1489 while (r->trivial.i_counter >= r->i_ss.rate) {
1490 pa_assert(r->trivial.o_counter >= r->o_ss.rate);
1491
1492 r->trivial.i_counter -= r->i_ss.rate;
1493 r->trivial.o_counter -= r->o_ss.rate;
1494 }
1495 }
1496
1497 static void trivial_update_rates_or_reset(pa_resampler *r) {
1498 pa_assert(r);
1499
1500 r->trivial.i_counter = 0;
1501 r->trivial.o_counter = 0;
1502 }
1503
1504 static int trivial_init(pa_resampler*r) {
1505 pa_assert(r);
1506
1507 r->trivial.o_counter = r->trivial.i_counter = 0;
1508
1509 r->impl_resample = trivial_resample;
1510 r->impl_update_rates = trivial_update_rates_or_reset;
1511 r->impl_reset = trivial_update_rates_or_reset;
1512
1513 return 0;
1514 }
1515
1516 /* Peak finder implementation */
1517
1518 static void peaks_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
1519 size_t fz;
1520 unsigned o_index;
1521 void *src, *dst;
1522 unsigned start = 0;
1523
1524 pa_assert(r);
1525 pa_assert(input);
1526 pa_assert(output);
1527 pa_assert(out_n_frames);
1528
1529 fz = r->w_sz * r->o_ss.channels;
1530
1531 src = (uint8_t*) pa_memblock_acquire(input->memblock) + input->index;
1532 dst = (uint8_t*) pa_memblock_acquire(output->memblock) + output->index;
1533
1534 for (o_index = 0;; o_index++, r->peaks.o_counter++) {
1535 unsigned j;
1536
1537 j = ((r->peaks.o_counter * r->i_ss.rate) / r->o_ss.rate);
1538
1539 if (j > r->peaks.i_counter)
1540 j -= r->peaks.i_counter;
1541 else
1542 j = 0;
1543
1544 pa_assert(o_index * fz < pa_memblock_get_length(output->memblock));
1545
1546 if (r->work_format == PA_SAMPLE_S16NE) {
1547 unsigned i, c;
1548 int16_t *s = (int16_t*) ((uint8_t*) src + fz * start);
1549 int16_t *d = (int16_t*) ((uint8_t*) dst + fz * o_index);
1550
1551 for (i = start; i <= j && i < in_n_frames; i++)
1552
1553 for (c = 0; c < r->o_ss.channels; c++, s++) {
1554 int16_t n;
1555
1556 n = (int16_t) (*s < 0 ? -*s : *s);
1557
1558 if (PA_UNLIKELY(n > r->peaks.max_i[c]))
1559 r->peaks.max_i[c] = n;
1560 }
1561
1562 if (i >= in_n_frames)
1563 break;
1564
1565 for (c = 0; c < r->o_ss.channels; c++, d++) {
1566 *d = r->peaks.max_i[c];
1567 r->peaks.max_i[c] = 0;
1568 }
1569
1570 } else {
1571 unsigned i, c;
1572 float *s = (float*) ((uint8_t*) src + fz * start);
1573 float *d = (float*) ((uint8_t*) dst + fz * o_index);
1574
1575 pa_assert(r->work_format == PA_SAMPLE_FLOAT32NE);
1576
1577 for (i = start; i <= j && i < in_n_frames; i++)
1578 for (c = 0; c < r->o_ss.channels; c++, s++) {
1579 float n = fabsf(*s);
1580
1581 if (n > r->peaks.max_f[c])
1582 r->peaks.max_f[c] = n;
1583 }
1584
1585 if (i >= in_n_frames)
1586 break;
1587
1588 for (c = 0; c < r->o_ss.channels; c++, d++) {
1589 *d = r->peaks.max_f[c];
1590 r->peaks.max_f[c] = 0;
1591 }
1592 }
1593
1594 start = j;
1595 }
1596
1597 pa_memblock_release(input->memblock);
1598 pa_memblock_release(output->memblock);
1599
1600 *out_n_frames = o_index;
1601
1602 r->peaks.i_counter += in_n_frames;
1603
1604 /* Normalize counters */
1605 while (r->peaks.i_counter >= r->i_ss.rate) {
1606 pa_assert(r->peaks.o_counter >= r->o_ss.rate);
1607
1608 r->peaks.i_counter -= r->i_ss.rate;
1609 r->peaks.o_counter -= r->o_ss.rate;
1610 }
1611 }
1612
1613 static void peaks_update_rates_or_reset(pa_resampler *r) {
1614 pa_assert(r);
1615
1616 r->peaks.i_counter = 0;
1617 r->peaks.o_counter = 0;
1618 }
1619
1620 static int peaks_init(pa_resampler*r) {
1621 pa_assert(r);
1622
1623 r->peaks.o_counter = r->peaks.i_counter = 0;
1624 memset(r->peaks.max_i, 0, sizeof(r->peaks.max_i));
1625 memset(r->peaks.max_f, 0, sizeof(r->peaks.max_f));
1626
1627 r->impl_resample = peaks_resample;
1628 r->impl_update_rates = peaks_update_rates_or_reset;
1629 r->impl_reset = peaks_update_rates_or_reset;
1630
1631 return 0;
1632 }
1633
1634 /*** ffmpeg based implementation ***/
1635
1636 static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
1637 unsigned used_frames = 0, c;
1638
1639 pa_assert(r);
1640 pa_assert(input);
1641 pa_assert(output);
1642 pa_assert(out_n_frames);
1643
1644 for (c = 0; c < r->o_ss.channels; c++) {
1645 unsigned u;
1646 pa_memblock *b, *w;
1647 int16_t *p, *t, *k, *q, *s;
1648 int consumed_frames;
1649 unsigned in, l;
1650
1651 /* Allocate a new block */
1652 b = pa_memblock_new(r->mempool, r->ffmpeg.buf[c].length + in_n_frames * sizeof(int16_t));
1653 p = pa_memblock_acquire(b);
1654
1655 /* Copy the remaining data into it */
1656 l = (unsigned) r->ffmpeg.buf[c].length;
1657 if (r->ffmpeg.buf[c].memblock) {
1658 t = (int16_t*) ((uint8_t*) pa_memblock_acquire(r->ffmpeg.buf[c].memblock) + r->ffmpeg.buf[c].index);
1659 memcpy(p, t, l);
1660 pa_memblock_release(r->ffmpeg.buf[c].memblock);
1661 pa_memblock_unref(r->ffmpeg.buf[c].memblock);
1662 pa_memchunk_reset(&r->ffmpeg.buf[c]);
1663 }
1664
1665 /* Now append the new data, splitting up channels */
1666 t = ((int16_t*) ((uint8_t*) pa_memblock_acquire(input->memblock) + input->index)) + c;
1667 k = (int16_t*) ((uint8_t*) p + l);
1668 for (u = 0; u < in_n_frames; u++) {
1669 *k = *t;
1670 t += r->o_ss.channels;
1671 k ++;
1672 }
1673 pa_memblock_release(input->memblock);
1674
1675 /* Calculate the resulting number of frames */
1676 in = (unsigned) in_n_frames + l / (unsigned) sizeof(int16_t);
1677
1678 /* Allocate buffer for the result */
1679 w = pa_memblock_new(r->mempool, *out_n_frames * sizeof(int16_t));
1680 q = pa_memblock_acquire(w);
1681
1682 /* Now, resample */
1683 used_frames = (unsigned) av_resample(r->ffmpeg.state,
1684 q, p,
1685 &consumed_frames,
1686 (int) in, (int) *out_n_frames,
1687 c >= (unsigned) (r->o_ss.channels-1));
1688
1689 pa_memblock_release(b);
1690
1691 /* Now store the remaining samples away */
1692 pa_assert(consumed_frames <= (int) in);
1693 if (consumed_frames < (int) in) {
1694 r->ffmpeg.buf[c].memblock = b;
1695 r->ffmpeg.buf[c].index = (size_t) consumed_frames * sizeof(int16_t);
1696 r->ffmpeg.buf[c].length = (size_t) (in - (unsigned) consumed_frames) * sizeof(int16_t);
1697 } else
1698 pa_memblock_unref(b);
1699
1700 /* And place the results in the output buffer */
1701 s = (short*) ((uint8_t*) pa_memblock_acquire(output->memblock) + output->index) + c;
1702 for (u = 0; u < used_frames; u++) {
1703 *s = *q;
1704 q++;
1705 s += r->o_ss.channels;
1706 }
1707 pa_memblock_release(output->memblock);
1708 pa_memblock_release(w);
1709 pa_memblock_unref(w);
1710 }
1711
1712 *out_n_frames = used_frames;
1713 }
1714
1715 static void ffmpeg_free(pa_resampler *r) {
1716 unsigned c;
1717
1718 pa_assert(r);
1719
1720 if (r->ffmpeg.state)
1721 av_resample_close(r->ffmpeg.state);
1722
1723 for (c = 0; c < PA_ELEMENTSOF(r->ffmpeg.buf); c++)
1724 if (r->ffmpeg.buf[c].memblock)
1725 pa_memblock_unref(r->ffmpeg.buf[c].memblock);
1726 }
1727
1728 static int ffmpeg_init(pa_resampler *r) {
1729 unsigned c;
1730
1731 pa_assert(r);
1732
1733 /* We could probably implement different quality levels by
1734 * adjusting the filter parameters here. However, ffmpeg
1735 * internally only uses these hardcoded values, so let's use them
1736 * here for now as well until ffmpeg makes this configurable. */
1737
1738 if (!(r->ffmpeg.state = av_resample_init((int) r->o_ss.rate, (int) r->i_ss.rate, 16, 10, 0, 0.8)))
1739 return -1;
1740
1741 r->impl_free = ffmpeg_free;
1742 r->impl_resample = ffmpeg_resample;
1743
1744 for (c = 0; c < PA_ELEMENTSOF(r->ffmpeg.buf); c++)
1745 pa_memchunk_reset(&r->ffmpeg.buf[c]);
1746
1747 return 0;
1748 }
1749
1750 /*** copy (noop) implementation ***/
1751
1752 static int copy_init(pa_resampler *r) {
1753 pa_assert(r);
1754
1755 pa_assert(r->o_ss.rate == r->i_ss.rate);
1756
1757 return 0;
1758 }