2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
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.
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.
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
28 #ifdef HAVE_LIBSAMPLERATE
29 #include <samplerate.h>
32 #include <speex/speex_resampler.h>
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>
40 #include "ffmpeg/avcodec.h"
42 #include "resampler.h"
44 /* Number of samples of extra space we allow the resamplers to return */
45 #define EXTRA_FRAMES 128
47 typedef struct pa_remap pa_remap_t
;
49 typedef void (*pa_do_remap_func_t
) (pa_remap_t
*m
, void *d
, const void *s
, unsigned n
);
52 pa_sample_format_t
*format
;
53 pa_sample_spec
*i_ss
, *o_ss
;
54 float map_table_f
[PA_CHANNELS_MAX
][PA_CHANNELS_MAX
];
55 int32_t map_table_i
[PA_CHANNELS_MAX
][PA_CHANNELS_MAX
];
56 pa_do_remap_func_t do_remap
;
59 static void remap_channels_matrix (pa_remap_t
*m
, void *dst
, const void *src
, unsigned n
);
60 static void remap_mono_to_stereo(pa_remap_t
*m
, void *dst
, const void *src
, unsigned n
);
63 pa_resample_method_t method
;
64 pa_resample_flags_t flags
;
66 pa_sample_spec i_ss
, o_ss
;
67 pa_channel_map i_cm
, o_cm
;
68 size_t i_fz
, o_fz
, w_sz
;
71 pa_memchunk buf1
, buf2
, buf3
, buf4
;
72 unsigned buf1_samples
, buf2_samples
, buf3_samples
, buf4_samples
;
74 pa_sample_format_t work_format
;
76 pa_convert_func_t to_work_format_func
;
77 pa_convert_func_t from_work_format_func
;
80 pa_bool_t map_required
;
82 void (*impl_free
)(pa_resampler
*r
);
83 void (*impl_update_rates
)(pa_resampler
*r
);
84 void (*impl_resample
)(pa_resampler
*r
, const pa_memchunk
*in
, unsigned in_samples
, pa_memchunk
*out
, unsigned *out_samples
);
85 void (*impl_reset
)(pa_resampler
*r
);
87 struct { /* data specific to the trivial resampler */
92 struct { /* data specific to the peak finder pseudo resampler */
96 float max_f
[PA_CHANNELS_MAX
];
97 int16_t max_i
[PA_CHANNELS_MAX
];
101 #ifdef HAVE_LIBSAMPLERATE
102 struct { /* data specific to libsamplerate */
107 struct { /* data specific to speex */
108 SpeexResamplerState
* state
;
111 struct { /* data specific to ffmpeg */
112 struct AVResampleContext
*state
;
113 pa_memchunk buf
[PA_CHANNELS_MAX
];
117 static int copy_init(pa_resampler
*r
);
118 static int trivial_init(pa_resampler
*r
);
119 static int speex_init(pa_resampler
*r
);
120 static int ffmpeg_init(pa_resampler
*r
);
121 static int peaks_init(pa_resampler
*r
);
122 #ifdef HAVE_LIBSAMPLERATE
123 static int libsamplerate_init(pa_resampler
*r
);
126 static void calc_map_table(pa_resampler
*r
);
128 static int (* const init_table
[])(pa_resampler
*r
) = {
129 #ifdef HAVE_LIBSAMPLERATE
130 [PA_RESAMPLER_SRC_SINC_BEST_QUALITY
] = libsamplerate_init
,
131 [PA_RESAMPLER_SRC_SINC_MEDIUM_QUALITY
] = libsamplerate_init
,
132 [PA_RESAMPLER_SRC_SINC_FASTEST
] = libsamplerate_init
,
133 [PA_RESAMPLER_SRC_ZERO_ORDER_HOLD
] = libsamplerate_init
,
134 [PA_RESAMPLER_SRC_LINEAR
] = libsamplerate_init
,
136 [PA_RESAMPLER_SRC_SINC_BEST_QUALITY
] = NULL
,
137 [PA_RESAMPLER_SRC_SINC_MEDIUM_QUALITY
] = NULL
,
138 [PA_RESAMPLER_SRC_SINC_FASTEST
] = NULL
,
139 [PA_RESAMPLER_SRC_ZERO_ORDER_HOLD
] = NULL
,
140 [PA_RESAMPLER_SRC_LINEAR
] = NULL
,
142 [PA_RESAMPLER_TRIVIAL
] = trivial_init
,
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 [PA_RESAMPLER_FFMPEG
] = ffmpeg_init
,
166 [PA_RESAMPLER_AUTO
] = NULL
,
167 [PA_RESAMPLER_COPY
] = copy_init
,
168 [PA_RESAMPLER_PEAKS
] = peaks_init
,
171 pa_resampler
* pa_resampler_new(
173 const pa_sample_spec
*a
,
174 const pa_channel_map
*am
,
175 const pa_sample_spec
*b
,
176 const pa_channel_map
*bm
,
177 pa_resample_method_t method
,
178 pa_resample_flags_t flags
) {
180 pa_resampler
*r
= NULL
;
185 pa_assert(pa_sample_spec_valid(a
));
186 pa_assert(pa_sample_spec_valid(b
));
187 pa_assert(method
>= 0);
188 pa_assert(method
< PA_RESAMPLER_MAX
);
192 if (!(flags
& PA_RESAMPLER_VARIABLE_RATE
) && a
->rate
== b
->rate
) {
193 pa_log_info("Forcing resampler 'copy', because of fixed, identical sample rates.");
194 method
= PA_RESAMPLER_COPY
;
197 if (!pa_resample_method_supported(method
)) {
198 pa_log_warn("Support for resampler '%s' not compiled in, reverting to 'auto'.", pa_resample_method_to_string(method
));
199 method
= PA_RESAMPLER_AUTO
;
202 if (method
== PA_RESAMPLER_FFMPEG
&& (flags
& PA_RESAMPLER_VARIABLE_RATE
)) {
203 pa_log_info("Resampler 'ffmpeg' cannot do variable rate, reverting to resampler 'auto'.");
204 method
= PA_RESAMPLER_AUTO
;
207 if (method
== PA_RESAMPLER_COPY
&& ((flags
& PA_RESAMPLER_VARIABLE_RATE
) || a
->rate
!= b
->rate
)) {
208 pa_log_info("Resampler 'copy' cannot change sampling rate, reverting to resampler 'auto'.");
209 method
= PA_RESAMPLER_AUTO
;
212 if (method
== PA_RESAMPLER_AUTO
)
213 method
= PA_RESAMPLER_SPEEX_FLOAT_BASE
+ 3;
215 r
= pa_xnew(pa_resampler
, 1);
221 r
->impl_update_rates
= NULL
;
222 r
->impl_resample
= NULL
;
223 r
->impl_reset
= NULL
;
225 /* Fill sample specs */
229 /* set up the remap structure */
230 r
->remap
.i_ss
= &r
->i_ss
;
231 r
->remap
.o_ss
= &r
->o_ss
;
232 r
->remap
.format
= &r
->work_format
;
236 else if (!pa_channel_map_init_auto(&r
->i_cm
, r
->i_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
))
241 else if (!pa_channel_map_init_auto(&r
->o_cm
, r
->o_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
))
244 r
->i_fz
= pa_frame_size(a
);
245 r
->o_fz
= pa_frame_size(b
);
247 pa_memchunk_reset(&r
->buf1
);
248 pa_memchunk_reset(&r
->buf2
);
249 pa_memchunk_reset(&r
->buf3
);
250 pa_memchunk_reset(&r
->buf4
);
252 r
->buf1_samples
= r
->buf2_samples
= r
->buf3_samples
= r
->buf4_samples
= 0;
256 pa_log_info("Using resampler '%s'", pa_resample_method_to_string(method
));
258 if ((method
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& method
<= PA_RESAMPLER_SPEEX_FIXED_MAX
) ||
259 (method
== PA_RESAMPLER_FFMPEG
))
260 r
->work_format
= PA_SAMPLE_S16NE
;
261 else if (method
== PA_RESAMPLER_TRIVIAL
|| method
== PA_RESAMPLER_COPY
|| method
== PA_RESAMPLER_PEAKS
) {
263 if (r
->map_required
|| a
->format
!= b
->format
|| method
== PA_RESAMPLER_PEAKS
) {
265 if (a
->format
== PA_SAMPLE_S32NE
|| a
->format
== PA_SAMPLE_S32RE
||
266 a
->format
== PA_SAMPLE_FLOAT32NE
|| a
->format
== PA_SAMPLE_FLOAT32RE
||
267 a
->format
== PA_SAMPLE_S24NE
|| a
->format
== PA_SAMPLE_S24RE
||
268 a
->format
== PA_SAMPLE_S24_32NE
|| a
->format
== PA_SAMPLE_S24_32RE
||
269 b
->format
== PA_SAMPLE_S32NE
|| b
->format
== PA_SAMPLE_S32RE
||
270 b
->format
== PA_SAMPLE_FLOAT32NE
|| b
->format
== PA_SAMPLE_FLOAT32RE
||
271 b
->format
== PA_SAMPLE_S24NE
|| b
->format
== PA_SAMPLE_S24RE
||
272 b
->format
== PA_SAMPLE_S24_32NE
|| b
->format
== PA_SAMPLE_S24_32RE
)
273 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
275 r
->work_format
= PA_SAMPLE_S16NE
;
278 r
->work_format
= a
->format
;
281 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
283 pa_log_info("Using %s as working format.", pa_sample_format_to_string(r
->work_format
));
285 r
->w_sz
= pa_sample_size_of_format(r
->work_format
);
287 if (r
->i_ss
.format
== r
->work_format
)
288 r
->to_work_format_func
= NULL
;
289 else if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
290 if (!(r
->to_work_format_func
= pa_get_convert_to_float32ne_function(r
->i_ss
.format
)))
293 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
294 if (!(r
->to_work_format_func
= pa_get_convert_to_s16ne_function(r
->i_ss
.format
)))
298 if (r
->o_ss
.format
== r
->work_format
)
299 r
->from_work_format_func
= NULL
;
300 else if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
301 if (!(r
->from_work_format_func
= pa_get_convert_from_float32ne_function(r
->o_ss
.format
)))
304 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
305 if (!(r
->from_work_format_func
= pa_get_convert_from_s16ne_function(r
->o_ss
.format
)))
309 /* initialize implementation */
310 if (init_table
[method
](r
) < 0)
322 void pa_resampler_free(pa_resampler
*r
) {
328 if (r
->buf1
.memblock
)
329 pa_memblock_unref(r
->buf1
.memblock
);
330 if (r
->buf2
.memblock
)
331 pa_memblock_unref(r
->buf2
.memblock
);
332 if (r
->buf3
.memblock
)
333 pa_memblock_unref(r
->buf3
.memblock
);
334 if (r
->buf4
.memblock
)
335 pa_memblock_unref(r
->buf4
.memblock
);
340 void pa_resampler_set_input_rate(pa_resampler
*r
, uint32_t rate
) {
344 if (r
->i_ss
.rate
== rate
)
349 r
->impl_update_rates(r
);
352 void pa_resampler_set_output_rate(pa_resampler
*r
, uint32_t rate
) {
356 if (r
->o_ss
.rate
== rate
)
361 r
->impl_update_rates(r
);
364 size_t pa_resampler_request(pa_resampler
*r
, size_t out_length
) {
367 /* Let's round up here */
369 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
;
372 size_t pa_resampler_result(pa_resampler
*r
, size_t in_length
) {
375 /* Let's round up here */
377 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
;
380 size_t pa_resampler_max_block_size(pa_resampler
*r
) {
381 size_t block_size_max
;
387 block_size_max
= pa_mempool_block_size_max(r
->mempool
);
389 /* We deduce the "largest" sample spec we're using during the
391 ss
.channels
= (uint8_t) (PA_MAX(r
->i_ss
.channels
, r
->o_ss
.channels
));
393 /* We silently assume that the format enum is ordered by size */
394 ss
.format
= PA_MAX(r
->i_ss
.format
, r
->o_ss
.format
);
395 ss
.format
= PA_MAX(ss
.format
, r
->work_format
);
397 ss
.rate
= PA_MAX(r
->i_ss
.rate
, r
->o_ss
.rate
);
399 fs
= pa_frame_size(&ss
);
401 return (((block_size_max
/fs
- EXTRA_FRAMES
)*r
->i_ss
.rate
)/ss
.rate
)*r
->i_fz
;
404 void pa_resampler_reset(pa_resampler
*r
) {
411 pa_resample_method_t
pa_resampler_get_method(pa_resampler
*r
) {
417 const pa_channel_map
* pa_resampler_input_channel_map(pa_resampler
*r
) {
423 const pa_sample_spec
* pa_resampler_input_sample_spec(pa_resampler
*r
) {
429 const pa_channel_map
* pa_resampler_output_channel_map(pa_resampler
*r
) {
435 const pa_sample_spec
* pa_resampler_output_sample_spec(pa_resampler
*r
) {
441 static const char * const resample_methods
[] = {
442 "src-sinc-best-quality",
443 "src-sinc-medium-quality",
445 "src-zero-order-hold",
476 const char *pa_resample_method_to_string(pa_resample_method_t m
) {
478 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
481 return resample_methods
[m
];
484 int pa_resample_method_supported(pa_resample_method_t m
) {
486 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
489 #ifndef HAVE_LIBSAMPLERATE
490 if (m
<= PA_RESAMPLER_SRC_LINEAR
)
497 pa_resample_method_t
pa_parse_resample_method(const char *string
) {
498 pa_resample_method_t m
;
502 for (m
= 0; m
< PA_RESAMPLER_MAX
; m
++)
503 if (!strcmp(string
, resample_methods
[m
]))
506 if (!strcmp(string
, "speex-fixed"))
507 return PA_RESAMPLER_SPEEX_FIXED_BASE
+ 3;
509 if (!strcmp(string
, "speex-float"))
510 return PA_RESAMPLER_SPEEX_FLOAT_BASE
+ 3;
512 return PA_RESAMPLER_INVALID
;
515 static pa_bool_t
on_left(pa_channel_position_t p
) {
518 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
519 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
520 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
521 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
522 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
523 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
;
526 static pa_bool_t
on_right(pa_channel_position_t p
) {
529 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
530 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
531 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
||
532 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
533 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
534 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
;
537 static pa_bool_t
on_center(pa_channel_position_t p
) {
540 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
541 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
542 p
== PA_CHANNEL_POSITION_TOP_CENTER
||
543 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
544 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
547 static pa_bool_t
on_lfe(pa_channel_position_t p
) {
549 p
== PA_CHANNEL_POSITION_LFE
;
552 static pa_bool_t
on_front(pa_channel_position_t p
) {
554 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
555 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
556 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
557 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
558 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
559 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
560 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
561 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
;
564 static pa_bool_t
on_rear(pa_channel_position_t p
) {
566 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
567 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
568 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
569 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
||
570 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
||
571 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
574 static pa_bool_t
on_side(pa_channel_position_t p
) {
576 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
577 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
578 p
== PA_CHANNEL_POSITION_TOP_CENTER
;
588 static int front_rear_side(pa_channel_position_t p
) {
598 static void calc_map_table(pa_resampler
*r
) {
601 pa_bool_t ic_connected
[PA_CHANNELS_MAX
];
609 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
)))))
614 n_oc
= r
->o_ss
.channels
;
615 n_ic
= r
->i_ss
.channels
;
617 memset(m
->map_table_f
, 0, sizeof(m
->map_table_f
));
618 memset(m
->map_table_i
, 0, sizeof(m
->map_table_i
));
620 memset(ic_connected
, 0, sizeof(ic_connected
));
621 remix
= (r
->flags
& (PA_RESAMPLER_NO_REMAP
|PA_RESAMPLER_NO_REMIX
)) == 0;
623 for (oc
= 0; oc
< n_oc
; oc
++) {
624 pa_bool_t oc_connected
= FALSE
;
625 pa_channel_position_t b
= r
->o_cm
.map
[oc
];
627 for (ic
= 0; ic
< n_ic
; ic
++) {
628 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
630 if (r
->flags
& PA_RESAMPLER_NO_REMAP
) {
631 /* We shall not do any remapping. Hence, just check by index */
634 m
->map_table_f
[oc
][ic
] = 1.0;
639 if (r
->flags
& PA_RESAMPLER_NO_REMIX
) {
640 /* We shall not do any remixing. Hence, just check by name */
643 m
->map_table_f
[oc
][ic
] = 1.0;
650 /* OK, we shall do the full monty: upmixing and
651 * downmixing. Our algorithm is relatively simple, does
652 * not do spacialization, delay elements or apply lowpass
653 * filters for LFE. Patches are always welcome,
654 * though. Oh, and it doesn't do any matrix
655 * decoding. (Which probably wouldn't make any sense
658 * This code is not idempotent: downmixing an upmixed
659 * stereo stream is not identical to the original. The
660 * volume will not match, and the two channels will be a
661 * linear combination of both.
663 * This is losely based on random suggestions found on the
664 * Internet, such as this:
665 * http://www.halfgaar.net/surround-sound-in-linux and the
668 * The algorithm works basically like this:
670 * 1) Connect all channels with matching names.
673 * S:Mono: Copy into all D:channels
674 * D:Mono: Copy in all S:channels
676 * 3) Mix D:Left, D:Right:
677 * D:Left: If not connected, avg all S:Left
678 * D:Right: If not connected, avg all S:Right
681 * If not connected, avg all S:Center
682 * If still not connected, avg all S:Left, S:Right
685 * If not connected, avg all S:*
687 * 6) Make sure S:Left/S:Right is used: S:Left/S:Right: If
688 * not connected, mix into all D:left and all D:right
689 * channels. Gain is 0.1, the current left and right
690 * should be multiplied by 0.9.
692 * 7) Make sure S:Center, S:LFE is used:
694 * S:Center, S:LFE: If not connected, mix into all
695 * D:left, all D:right, all D:center channels, gain is
696 * 0.375. The current (as result of 1..6) factors
697 * should be multiplied by 0.75. (Alt. suggestion: 0.25
698 * vs. 0.5) If C-front is only mixed into
699 * L-front/R-front if available, otherwise into all L/R
700 * channels. Similarly for C-rear.
702 * S: and D: shall relate to the source resp. destination channels.
704 * Rationale: 1, 2 are probably obvious. For 3: this
705 * copies front to rear if needed. For 4: we try to find
706 * some suitable C source for C, if we don't find any, we
707 * avg L and R. For 5: LFE is mixed from all channels. For
708 * 6: the rear channels should not be dropped entirely,
709 * however have only minimal impact. For 7: movies usually
710 * encode speech on the center channel. Thus we have to
711 * make sure this channel is distributed to L and R if not
712 * available in the output. Also, LFE is used to achieve a
713 * greater dynamic range, and thus we should try to do our
714 * best to pass it to L+R.
717 if (a
== b
|| a
== PA_CHANNEL_POSITION_MONO
|| b
== PA_CHANNEL_POSITION_MONO
) {
718 m
->map_table_f
[oc
][ic
] = 1.0;
721 ic_connected
[ic
] = TRUE
;
725 if (!oc_connected
&& remix
) {
726 /* OK, we shall remix */
728 /* Try to find matching input ports for this output port */
733 /* We are not connected and on the left side, let's
734 * average all left side input channels. */
736 for (ic
= 0; ic
< n_ic
; ic
++)
737 if (on_left(r
->i_cm
.map
[ic
]))
741 for (ic
= 0; ic
< n_ic
; ic
++)
742 if (on_left(r
->i_cm
.map
[ic
])) {
743 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
744 ic_connected
[ic
] = TRUE
;
747 /* We ignore the case where there is no left input
748 * channel. Something is really wrong in this case
751 } else if (on_right(b
)) {
754 /* We are not connected and on the right side, let's
755 * average all right side input channels. */
757 for (ic
= 0; ic
< n_ic
; ic
++)
758 if (on_right(r
->i_cm
.map
[ic
]))
762 for (ic
= 0; ic
< n_ic
; ic
++)
763 if (on_right(r
->i_cm
.map
[ic
])) {
764 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
765 ic_connected
[ic
] = TRUE
;
768 /* We ignore the case where there is no right input
769 * channel. Something is really wrong in this case
772 } else if (on_center(b
)) {
775 /* We are not connected and at the center. Let's
776 * average all center input channels. */
778 for (ic
= 0; ic
< n_ic
; ic
++)
779 if (on_center(r
->i_cm
.map
[ic
]))
783 for (ic
= 0; ic
< n_ic
; ic
++)
784 if (on_center(r
->i_cm
.map
[ic
])) {
785 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
786 ic_connected
[ic
] = TRUE
;
790 /* Hmm, no center channel around, let's synthesize
791 * it by mixing L and R.*/
795 for (ic
= 0; ic
< n_ic
; ic
++)
796 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
]))
800 for (ic
= 0; ic
< n_ic
; ic
++)
801 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
])) {
802 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
803 ic_connected
[ic
] = TRUE
;
806 /* We ignore the case where there is not even a
807 * left or right input channel. Something is
808 * really wrong in this case anyway. */
811 } else if (on_lfe(b
)) {
813 /* We are not connected and an LFE. Let's average all
814 * channels for LFE. */
816 for (ic
= 0; ic
< n_ic
; ic
++) {
818 if (!(r
->flags
& PA_RESAMPLER_NO_LFE
))
819 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n_ic
;
821 m
->map_table_f
[oc
][ic
] = 0;
823 /* Please note that a channel connected to LFE
824 * doesn't really count as connected. */
832 ic_unconnected_left
= 0,
833 ic_unconnected_right
= 0,
834 ic_unconnected_center
= 0,
835 ic_unconnected_lfe
= 0;
837 for (ic
= 0; ic
< n_ic
; ic
++) {
838 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
840 if (ic_connected
[ic
])
844 ic_unconnected_left
++;
845 else if (on_right(a
))
846 ic_unconnected_right
++;
847 else if (on_center(a
))
848 ic_unconnected_center
++;
850 ic_unconnected_lfe
++;
853 if (ic_unconnected_left
> 0) {
855 /* OK, so there are unconnected input channels on the
856 * left. Let's multiply all already connected channels on
857 * the left side by .9 and add in our averaged unconnected
858 * channels multplied by .1 */
860 for (oc
= 0; oc
< n_oc
; oc
++) {
862 if (!on_left(r
->o_cm
.map
[oc
]))
865 for (ic
= 0; ic
< n_ic
; ic
++) {
867 if (ic_connected
[ic
]) {
868 m
->map_table_f
[oc
][ic
] *= .9f
;
872 if (on_left(r
->i_cm
.map
[ic
]))
873 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_left
;
878 if (ic_unconnected_right
> 0) {
880 /* OK, so there are unconnected input channels on the
881 * right. Let's multiply all already connected channels on
882 * the right side by .9 and add in our averaged unconnected
883 * channels multplied by .1 */
885 for (oc
= 0; oc
< n_oc
; oc
++) {
887 if (!on_right(r
->o_cm
.map
[oc
]))
890 for (ic
= 0; ic
< n_ic
; ic
++) {
892 if (ic_connected
[ic
]) {
893 m
->map_table_f
[oc
][ic
] *= .9f
;
897 if (on_right(r
->i_cm
.map
[ic
]))
898 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_right
;
903 if (ic_unconnected_center
> 0) {
904 pa_bool_t mixed_in
= FALSE
;
906 /* OK, so there are unconnected input channels on the
907 * center. Let's multiply all already connected channels on
908 * the center side by .9 and add in our averaged unconnected
909 * channels multplied by .1 */
911 for (oc
= 0; oc
< n_oc
; oc
++) {
913 if (!on_center(r
->o_cm
.map
[oc
]))
916 for (ic
= 0; ic
< n_ic
; ic
++) {
918 if (ic_connected
[ic
]) {
919 m
->map_table_f
[oc
][ic
] *= .9f
;
923 if (on_center(r
->i_cm
.map
[ic
])) {
924 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_center
;
931 unsigned ncenter
[PA_CHANNELS_MAX
];
932 pa_bool_t found_frs
[PA_CHANNELS_MAX
];
934 memset(ncenter
, 0, sizeof(ncenter
));
935 memset(found_frs
, 0, sizeof(found_frs
));
937 /* Hmm, as it appears there was no center channel we
938 could mix our center channel in. In this case, mix
939 it into left and right. Using .375 and 0.75 as
942 for (ic
= 0; ic
< n_ic
; ic
++) {
944 if (ic_connected
[ic
])
947 if (!on_center(r
->i_cm
.map
[ic
]))
950 for (oc
= 0; oc
< n_oc
; oc
++) {
952 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
955 if (front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
])) {
956 found_frs
[ic
] = TRUE
;
961 for (oc
= 0; oc
< n_oc
; oc
++) {
963 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
966 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
971 for (oc
= 0; oc
< n_oc
; oc
++) {
973 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
976 if (ncenter
[oc
] <= 0)
979 for (ic
= 0; ic
< n_ic
; ic
++) {
981 if (ic_connected
[ic
]) {
982 m
->map_table_f
[oc
][ic
] *= .75f
;
986 if (!on_center(r
->i_cm
.map
[ic
]))
989 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
990 m
->map_table_f
[oc
][ic
] = .375f
/ (float) ncenter
[oc
];
996 if (ic_unconnected_lfe
> 0 && !(r
->flags
& PA_RESAMPLER_NO_LFE
)) {
998 /* OK, so there is an unconnected LFE channel. Let's mix
999 * it into all channels, with factor 0.375 */
1001 for (ic
= 0; ic
< n_ic
; ic
++) {
1003 if (!on_lfe(r
->i_cm
.map
[ic
]))
1006 for (oc
= 0; oc
< n_oc
; oc
++)
1007 m
->map_table_f
[oc
][ic
] = 0.375f
/ (float) ic_unconnected_lfe
;
1011 /* make an 16:16 int version of the matrix */
1012 for (oc
= 0; oc
< n_oc
; oc
++)
1013 for (ic
= 0; ic
< n_ic
; ic
++)
1014 m
->map_table_i
[oc
][ic
] = (int32_t) (m
->map_table_f
[oc
][ic
] * 0x10000);
1016 s
= pa_strbuf_new();
1018 pa_strbuf_printf(s
, " ");
1019 for (ic
= 0; ic
< n_ic
; ic
++)
1020 pa_strbuf_printf(s
, " I%02u ", ic
);
1021 pa_strbuf_puts(s
, "\n +");
1023 for (ic
= 0; ic
< n_ic
; ic
++)
1024 pa_strbuf_printf(s
, "------");
1025 pa_strbuf_puts(s
, "\n");
1027 for (oc
= 0; oc
< n_oc
; oc
++) {
1028 pa_strbuf_printf(s
, "O%02u |", oc
);
1030 for (ic
= 0; ic
< n_ic
; ic
++)
1031 pa_strbuf_printf(s
, " %1.3f", m
->map_table_f
[oc
][ic
]);
1033 pa_strbuf_puts(s
, "\n");
1036 pa_log_debug("Channel matrix:\n%s", t
= pa_strbuf_tostring_free(s
));
1039 /* find some common channel remappings, fall back to full matrix operation. */
1040 if (n_ic
== 1 && n_oc
== 2 &&
1041 m
->map_table_f
[0][0] >= 1.0 && m
->map_table_f
[1][0] >= 1.0) {
1042 m
->do_remap
= (pa_do_remap_func_t
) remap_mono_to_stereo
;;
1043 pa_log_info("Using mono to stereo remapping");
1045 m
->do_remap
= (pa_do_remap_func_t
) remap_channels_matrix
;
1046 pa_log_info("Using generic matrix remapping");
1051 static pa_memchunk
* convert_to_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1057 pa_assert(input
->memblock
);
1059 /* Convert the incoming sample into the work sample format and place them in buf1 */
1061 if (!r
->to_work_format_func
|| !input
->length
)
1064 n_samples
= (unsigned) ((input
->length
/ r
->i_fz
) * r
->i_ss
.channels
);
1067 r
->buf1
.length
= r
->w_sz
* n_samples
;
1069 if (!r
->buf1
.memblock
|| r
->buf1_samples
< n_samples
) {
1070 if (r
->buf1
.memblock
)
1071 pa_memblock_unref(r
->buf1
.memblock
);
1073 r
->buf1_samples
= n_samples
;
1074 r
->buf1
.memblock
= pa_memblock_new(r
->mempool
, r
->buf1
.length
);
1077 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1078 dst
= (uint8_t*) pa_memblock_acquire(r
->buf1
.memblock
);
1080 r
->to_work_format_func(n_samples
, src
, dst
);
1082 pa_memblock_release(input
->memblock
);
1083 pa_memblock_release(r
->buf1
.memblock
);
1088 static void remap_mono_to_stereo(pa_remap_t
*m
, void *dst
, const void *src
, unsigned n
) {
1091 switch (*m
->format
) {
1092 case PA_SAMPLE_FLOAT32NE
:
1099 for (i
= n
>> 2; i
; i
--) {
1107 for (i
= n
& 3; i
; i
--) {
1114 case PA_SAMPLE_S16NE
:
1118 d
= (int16_t *) dst
;
1119 s
= (int16_t *) src
;
1121 for (i
= n
>> 2; i
; i
--) {
1129 for (i
= n
& 3; i
; i
--) {
1137 pa_assert_not_reached();
1141 static void remap_channels_matrix (pa_remap_t
*m
, void *dst
, const void *src
, unsigned n
) {
1143 unsigned n_ic
, n_oc
;
1145 n_ic
= m
->i_ss
->channels
;
1146 n_oc
= m
->o_ss
->channels
;
1148 switch (*m
->format
) {
1149 case PA_SAMPLE_FLOAT32NE
:
1153 memset(dst
, 0, n
* sizeof (float) * n_oc
);
1155 for (oc
= 0; oc
< n_oc
; oc
++) {
1157 for (ic
= 0; ic
< n_ic
; ic
++) {
1160 vol
= m
->map_table_f
[oc
][ic
];
1165 d
= (float *)dst
+ oc
;
1166 s
= (float *)src
+ ic
;
1169 for (i
= n
; i
> 0; i
--, s
+= n_ic
, d
+= n_oc
)
1172 for (i
= n
; i
> 0; i
--, s
+= n_ic
, d
+= n_oc
)
1180 case PA_SAMPLE_S16NE
:
1184 memset(dst
, 0, n
* sizeof (int16_t) * n_oc
);
1186 for (oc
= 0; oc
< n_oc
; oc
++) {
1188 for (ic
= 0; ic
< n_ic
; ic
++) {
1191 vol
= m
->map_table_i
[oc
][ic
];
1196 d
= (int16_t *)dst
+ oc
;
1197 s
= (int16_t *)src
+ ic
;
1199 if (vol
>= 0x10000) {
1200 for (i
= n
; i
> 0; i
--, s
+= n_ic
, d
+= n_oc
)
1203 for (i
= n
; i
> 0; i
--, s
+= n_ic
, d
+= n_oc
)
1204 *d
+= (int16_t) (((int32_t)*s
* vol
) >> 16);
1211 pa_assert_not_reached();
1215 static pa_memchunk
*remap_channels(pa_resampler
*r
, pa_memchunk
*input
) {
1216 unsigned in_n_samples
, out_n_samples
, n_frames
;
1222 pa_assert(input
->memblock
);
1224 /* Remap channels and place the result int buf2 */
1226 if (!r
->map_required
|| !input
->length
)
1229 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1230 n_frames
= in_n_samples
/ r
->i_ss
.channels
;
1231 out_n_samples
= n_frames
* r
->o_ss
.channels
;
1234 r
->buf2
.length
= r
->w_sz
* out_n_samples
;
1236 if (!r
->buf2
.memblock
|| r
->buf2_samples
< out_n_samples
) {
1237 if (r
->buf2
.memblock
)
1238 pa_memblock_unref(r
->buf2
.memblock
);
1240 r
->buf2_samples
= out_n_samples
;
1241 r
->buf2
.memblock
= pa_memblock_new(r
->mempool
, r
->buf2
.length
);
1244 src
= ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1245 dst
= pa_memblock_acquire(r
->buf2
.memblock
);
1249 pa_assert (remap
->do_remap
);
1250 remap
->do_remap (remap
, dst
, src
, n_frames
);
1252 pa_memblock_release(input
->memblock
);
1253 pa_memblock_release(r
->buf2
.memblock
);
1258 static pa_memchunk
*resample(pa_resampler
*r
, pa_memchunk
*input
) {
1259 unsigned in_n_frames
, in_n_samples
;
1260 unsigned out_n_frames
, out_n_samples
;
1265 /* Resample the data and place the result in buf3 */
1267 if (!r
->impl_resample
|| !input
->length
)
1270 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1271 in_n_frames
= (unsigned) (in_n_samples
/ r
->o_ss
.channels
);
1273 out_n_frames
= ((in_n_frames
*r
->o_ss
.rate
)/r
->i_ss
.rate
)+EXTRA_FRAMES
;
1274 out_n_samples
= out_n_frames
* r
->o_ss
.channels
;
1277 r
->buf3
.length
= r
->w_sz
* out_n_samples
;
1279 if (!r
->buf3
.memblock
|| r
->buf3_samples
< out_n_samples
) {
1280 if (r
->buf3
.memblock
)
1281 pa_memblock_unref(r
->buf3
.memblock
);
1283 r
->buf3_samples
= out_n_samples
;
1284 r
->buf3
.memblock
= pa_memblock_new(r
->mempool
, r
->buf3
.length
);
1287 r
->impl_resample(r
, input
, in_n_frames
, &r
->buf3
, &out_n_frames
);
1288 r
->buf3
.length
= out_n_frames
* r
->w_sz
* r
->o_ss
.channels
;
1293 static pa_memchunk
*convert_from_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1294 unsigned n_samples
, n_frames
;
1300 /* Convert the data into the correct sample type and place the result in buf4 */
1302 if (!r
->from_work_format_func
|| !input
->length
)
1305 n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1306 n_frames
= n_samples
/ r
->o_ss
.channels
;
1309 r
->buf4
.length
= r
->o_fz
* n_frames
;
1311 if (!r
->buf4
.memblock
|| r
->buf4_samples
< n_samples
) {
1312 if (r
->buf4
.memblock
)
1313 pa_memblock_unref(r
->buf4
.memblock
);
1315 r
->buf4_samples
= n_samples
;
1316 r
->buf4
.memblock
= pa_memblock_new(r
->mempool
, r
->buf4
.length
);
1319 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1320 dst
= pa_memblock_acquire(r
->buf4
.memblock
);
1321 r
->from_work_format_func(n_samples
, src
, dst
);
1322 pa_memblock_release(input
->memblock
);
1323 pa_memblock_release(r
->buf4
.memblock
);
1325 r
->buf4
.length
= r
->o_fz
* n_frames
;
1330 void pa_resampler_run(pa_resampler
*r
, const pa_memchunk
*in
, pa_memchunk
*out
) {
1336 pa_assert(in
->length
);
1337 pa_assert(in
->memblock
);
1338 pa_assert(in
->length
% r
->i_fz
== 0);
1340 buf
= (pa_memchunk
*) in
;
1341 buf
= convert_to_work_format(r
, buf
);
1342 buf
= remap_channels(r
, buf
);
1343 buf
= resample(r
, buf
);
1346 buf
= convert_from_work_format(r
, buf
);
1350 pa_memblock_ref(buf
->memblock
);
1352 pa_memchunk_reset(buf
);
1354 pa_memchunk_reset(out
);
1357 /*** libsamplerate based implementation ***/
1359 #ifdef HAVE_LIBSAMPLERATE
1360 static void libsamplerate_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1366 pa_assert(out_n_frames
);
1368 memset(&data
, 0, sizeof(data
));
1370 data
.data_in
= (float*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1371 data
.input_frames
= (long int) in_n_frames
;
1373 data
.data_out
= (float*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
);
1374 data
.output_frames
= (long int) *out_n_frames
;
1376 data
.src_ratio
= (double) r
->o_ss
.rate
/ r
->i_ss
.rate
;
1377 data
.end_of_input
= 0;
1379 pa_assert_se(src_process(r
->src
.state
, &data
) == 0);
1380 pa_assert((unsigned) data
.input_frames_used
== in_n_frames
);
1382 pa_memblock_release(input
->memblock
);
1383 pa_memblock_release(output
->memblock
);
1385 *out_n_frames
= (unsigned) data
.output_frames_gen
;
1388 static void libsamplerate_update_rates(pa_resampler
*r
) {
1391 pa_assert_se(src_set_ratio(r
->src
.state
, (double) r
->o_ss
.rate
/ r
->i_ss
.rate
) == 0);
1394 static void libsamplerate_reset(pa_resampler
*r
) {
1397 pa_assert_se(src_reset(r
->src
.state
) == 0);
1400 static void libsamplerate_free(pa_resampler
*r
) {
1404 src_delete(r
->src
.state
);
1407 static int libsamplerate_init(pa_resampler
*r
) {
1412 if (!(r
->src
.state
= src_new(r
->method
, r
->o_ss
.channels
, &err
)))
1415 r
->impl_free
= libsamplerate_free
;
1416 r
->impl_update_rates
= libsamplerate_update_rates
;
1417 r
->impl_resample
= libsamplerate_resample
;
1418 r
->impl_reset
= libsamplerate_reset
;
1424 /*** speex based implementation ***/
1426 static void speex_resample_float(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1428 uint32_t inf
= in_n_frames
, outf
= *out_n_frames
;
1433 pa_assert(out_n_frames
);
1435 in
= (float*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1436 out
= (float*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
);
1438 pa_assert_se(speex_resampler_process_interleaved_float(r
->speex
.state
, in
, &inf
, out
, &outf
) == 0);
1440 pa_memblock_release(input
->memblock
);
1441 pa_memblock_release(output
->memblock
);
1443 pa_assert(inf
== in_n_frames
);
1444 *out_n_frames
= outf
;
1447 static void speex_resample_int(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1449 uint32_t inf
= in_n_frames
, outf
= *out_n_frames
;
1454 pa_assert(out_n_frames
);
1456 in
= (int16_t*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1457 out
= (int16_t*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
);
1459 pa_assert_se(speex_resampler_process_interleaved_int(r
->speex
.state
, in
, &inf
, out
, &outf
) == 0);
1461 pa_memblock_release(input
->memblock
);
1462 pa_memblock_release(output
->memblock
);
1464 pa_assert(inf
== in_n_frames
);
1465 *out_n_frames
= outf
;
1468 static void speex_update_rates(pa_resampler
*r
) {
1471 pa_assert_se(speex_resampler_set_rate(r
->speex
.state
, r
->i_ss
.rate
, r
->o_ss
.rate
) == 0);
1474 static void speex_reset(pa_resampler
*r
) {
1477 pa_assert_se(speex_resampler_reset_mem(r
->speex
.state
) == 0);
1480 static void speex_free(pa_resampler
*r
) {
1483 if (!r
->speex
.state
)
1486 speex_resampler_destroy(r
->speex
.state
);
1489 static int speex_init(pa_resampler
*r
) {
1494 r
->impl_free
= speex_free
;
1495 r
->impl_update_rates
= speex_update_rates
;
1496 r
->impl_reset
= speex_reset
;
1498 if (r
->method
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& r
->method
<= PA_RESAMPLER_SPEEX_FIXED_MAX
) {
1500 q
= r
->method
- PA_RESAMPLER_SPEEX_FIXED_BASE
;
1501 r
->impl_resample
= speex_resample_int
;
1504 pa_assert(r
->method
>= PA_RESAMPLER_SPEEX_FLOAT_BASE
&& r
->method
<= PA_RESAMPLER_SPEEX_FLOAT_MAX
);
1506 q
= r
->method
- PA_RESAMPLER_SPEEX_FLOAT_BASE
;
1507 r
->impl_resample
= speex_resample_float
;
1510 pa_log_info("Choosing speex quality setting %i.", q
);
1512 if (!(r
->speex
.state
= speex_resampler_init(r
->o_ss
.channels
, r
->i_ss
.rate
, r
->o_ss
.rate
, q
, &err
)))
1518 /* Trivial implementation */
1520 static void trivial_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1528 pa_assert(out_n_frames
);
1530 fz
= r
->w_sz
* r
->o_ss
.channels
;
1532 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1533 dst
= (uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
;
1535 for (o_index
= 0;; o_index
++, r
->trivial
.o_counter
++) {
1538 j
= ((r
->trivial
.o_counter
* r
->i_ss
.rate
) / r
->o_ss
.rate
);
1539 j
= j
> r
->trivial
.i_counter
? j
- r
->trivial
.i_counter
: 0;
1541 if (j
>= in_n_frames
)
1544 pa_assert(o_index
* fz
< pa_memblock_get_length(output
->memblock
));
1546 memcpy((uint8_t*) dst
+ fz
* o_index
,
1547 (uint8_t*) src
+ fz
* j
, (int) fz
);
1550 pa_memblock_release(input
->memblock
);
1551 pa_memblock_release(output
->memblock
);
1553 *out_n_frames
= o_index
;
1555 r
->trivial
.i_counter
+= in_n_frames
;
1557 /* Normalize counters */
1558 while (r
->trivial
.i_counter
>= r
->i_ss
.rate
) {
1559 pa_assert(r
->trivial
.o_counter
>= r
->o_ss
.rate
);
1561 r
->trivial
.i_counter
-= r
->i_ss
.rate
;
1562 r
->trivial
.o_counter
-= r
->o_ss
.rate
;
1566 static void trivial_update_rates_or_reset(pa_resampler
*r
) {
1569 r
->trivial
.i_counter
= 0;
1570 r
->trivial
.o_counter
= 0;
1573 static int trivial_init(pa_resampler
*r
) {
1576 r
->trivial
.o_counter
= r
->trivial
.i_counter
= 0;
1578 r
->impl_resample
= trivial_resample
;
1579 r
->impl_update_rates
= trivial_update_rates_or_reset
;
1580 r
->impl_reset
= trivial_update_rates_or_reset
;
1585 /* Peak finder implementation */
1587 static void peaks_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1596 pa_assert(out_n_frames
);
1598 fz
= r
->w_sz
* r
->o_ss
.channels
;
1600 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1601 dst
= (uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
;
1603 for (o_index
= 0;; o_index
++, r
->peaks
.o_counter
++) {
1606 j
= ((r
->peaks
.o_counter
* r
->i_ss
.rate
) / r
->o_ss
.rate
);
1608 if (j
> r
->peaks
.i_counter
)
1609 j
-= r
->peaks
.i_counter
;
1613 pa_assert(o_index
* fz
< pa_memblock_get_length(output
->memblock
));
1615 if (r
->work_format
== PA_SAMPLE_S16NE
) {
1617 int16_t *s
= (int16_t*) ((uint8_t*) src
+ fz
* start
);
1618 int16_t *d
= (int16_t*) ((uint8_t*) dst
+ fz
* o_index
);
1620 for (i
= start
; i
<= j
&& i
< in_n_frames
; i
++)
1622 for (c
= 0; c
< r
->o_ss
.channels
; c
++, s
++) {
1625 n
= (int16_t) (*s
< 0 ? -*s
: *s
);
1627 if (PA_UNLIKELY(n
> r
->peaks
.max_i
[c
]))
1628 r
->peaks
.max_i
[c
] = n
;
1631 if (i
>= in_n_frames
)
1634 for (c
= 0; c
< r
->o_ss
.channels
; c
++, d
++) {
1635 *d
= r
->peaks
.max_i
[c
];
1636 r
->peaks
.max_i
[c
] = 0;
1641 float *s
= (float*) ((uint8_t*) src
+ fz
* start
);
1642 float *d
= (float*) ((uint8_t*) dst
+ fz
* o_index
);
1644 pa_assert(r
->work_format
== PA_SAMPLE_FLOAT32NE
);
1646 for (i
= start
; i
<= j
&& i
< in_n_frames
; i
++)
1647 for (c
= 0; c
< r
->o_ss
.channels
; c
++, s
++) {
1648 float n
= fabsf(*s
);
1650 if (n
> r
->peaks
.max_f
[c
])
1651 r
->peaks
.max_f
[c
] = n
;
1654 if (i
>= in_n_frames
)
1657 for (c
= 0; c
< r
->o_ss
.channels
; c
++, d
++) {
1658 *d
= r
->peaks
.max_f
[c
];
1659 r
->peaks
.max_f
[c
] = 0;
1666 pa_memblock_release(input
->memblock
);
1667 pa_memblock_release(output
->memblock
);
1669 *out_n_frames
= o_index
;
1671 r
->peaks
.i_counter
+= in_n_frames
;
1673 /* Normalize counters */
1674 while (r
->peaks
.i_counter
>= r
->i_ss
.rate
) {
1675 pa_assert(r
->peaks
.o_counter
>= r
->o_ss
.rate
);
1677 r
->peaks
.i_counter
-= r
->i_ss
.rate
;
1678 r
->peaks
.o_counter
-= r
->o_ss
.rate
;
1682 static void peaks_update_rates_or_reset(pa_resampler
*r
) {
1685 r
->peaks
.i_counter
= 0;
1686 r
->peaks
.o_counter
= 0;
1689 static int peaks_init(pa_resampler
*r
) {
1692 r
->peaks
.o_counter
= r
->peaks
.i_counter
= 0;
1693 memset(r
->peaks
.max_i
, 0, sizeof(r
->peaks
.max_i
));
1694 memset(r
->peaks
.max_f
, 0, sizeof(r
->peaks
.max_f
));
1696 r
->impl_resample
= peaks_resample
;
1697 r
->impl_update_rates
= peaks_update_rates_or_reset
;
1698 r
->impl_reset
= peaks_update_rates_or_reset
;
1703 /*** ffmpeg based implementation ***/
1705 static void ffmpeg_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1706 unsigned used_frames
= 0, c
;
1711 pa_assert(out_n_frames
);
1713 for (c
= 0; c
< r
->o_ss
.channels
; c
++) {
1716 int16_t *p
, *t
, *k
, *q
, *s
;
1717 int consumed_frames
;
1720 /* Allocate a new block */
1721 b
= pa_memblock_new(r
->mempool
, r
->ffmpeg
.buf
[c
].length
+ in_n_frames
* sizeof(int16_t));
1722 p
= pa_memblock_acquire(b
);
1724 /* Copy the remaining data into it */
1725 l
= (unsigned) r
->ffmpeg
.buf
[c
].length
;
1726 if (r
->ffmpeg
.buf
[c
].memblock
) {
1727 t
= (int16_t*) ((uint8_t*) pa_memblock_acquire(r
->ffmpeg
.buf
[c
].memblock
) + r
->ffmpeg
.buf
[c
].index
);
1729 pa_memblock_release(r
->ffmpeg
.buf
[c
].memblock
);
1730 pa_memblock_unref(r
->ffmpeg
.buf
[c
].memblock
);
1731 pa_memchunk_reset(&r
->ffmpeg
.buf
[c
]);
1734 /* Now append the new data, splitting up channels */
1735 t
= ((int16_t*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
)) + c
;
1736 k
= (int16_t*) ((uint8_t*) p
+ l
);
1737 for (u
= 0; u
< in_n_frames
; u
++) {
1739 t
+= r
->o_ss
.channels
;
1742 pa_memblock_release(input
->memblock
);
1744 /* Calculate the resulting number of frames */
1745 in
= (unsigned) in_n_frames
+ l
/ (unsigned) sizeof(int16_t);
1747 /* Allocate buffer for the result */
1748 w
= pa_memblock_new(r
->mempool
, *out_n_frames
* sizeof(int16_t));
1749 q
= pa_memblock_acquire(w
);
1752 used_frames
= (unsigned) av_resample(r
->ffmpeg
.state
,
1755 (int) in
, (int) *out_n_frames
,
1756 c
>= (unsigned) (r
->o_ss
.channels
-1));
1758 pa_memblock_release(b
);
1760 /* Now store the remaining samples away */
1761 pa_assert(consumed_frames
<= (int) in
);
1762 if (consumed_frames
< (int) in
) {
1763 r
->ffmpeg
.buf
[c
].memblock
= b
;
1764 r
->ffmpeg
.buf
[c
].index
= (size_t) consumed_frames
* sizeof(int16_t);
1765 r
->ffmpeg
.buf
[c
].length
= (size_t) (in
- (unsigned) consumed_frames
) * sizeof(int16_t);
1767 pa_memblock_unref(b
);
1769 /* And place the results in the output buffer */
1770 s
= (short*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
) + c
;
1771 for (u
= 0; u
< used_frames
; u
++) {
1774 s
+= r
->o_ss
.channels
;
1776 pa_memblock_release(output
->memblock
);
1777 pa_memblock_release(w
);
1778 pa_memblock_unref(w
);
1781 *out_n_frames
= used_frames
;
1784 static void ffmpeg_free(pa_resampler
*r
) {
1789 if (r
->ffmpeg
.state
)
1790 av_resample_close(r
->ffmpeg
.state
);
1792 for (c
= 0; c
< PA_ELEMENTSOF(r
->ffmpeg
.buf
); c
++)
1793 if (r
->ffmpeg
.buf
[c
].memblock
)
1794 pa_memblock_unref(r
->ffmpeg
.buf
[c
].memblock
);
1797 static int ffmpeg_init(pa_resampler
*r
) {
1802 /* We could probably implement different quality levels by
1803 * adjusting the filter parameters here. However, ffmpeg
1804 * internally only uses these hardcoded values, so let's use them
1805 * here for now as well until ffmpeg makes this configurable. */
1807 if (!(r
->ffmpeg
.state
= av_resample_init((int) r
->o_ss
.rate
, (int) r
->i_ss
.rate
, 16, 10, 0, 0.8)))
1810 r
->impl_free
= ffmpeg_free
;
1811 r
->impl_resample
= ffmpeg_resample
;
1813 for (c
= 0; c
< PA_ELEMENTSOF(r
->ffmpeg
.buf
); c
++)
1814 pa_memchunk_reset(&r
->ffmpeg
.buf
[c
]);
1819 /*** copy (noop) implementation ***/
1821 static int copy_init(pa_resampler
*r
) {
1824 pa_assert(r
->o_ss
.rate
== r
->i_ss
.rate
);