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