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