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