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>
33 #include <speex/speex_resampler.h>
36 #include <pulse/xmalloc.h>
37 #include <pulsecore/sconv.h>
38 #include <pulsecore/log.h>
39 #include <pulsecore/macro.h>
40 #include <pulsecore/strbuf.h>
41 #include <pulsecore/remap.h>
42 #include <pulsecore/core-util.h>
43 #include "ffmpeg/avcodec.h"
45 #include "resampler.h"
47 /* Number of samples of extra space we allow the resamplers to return */
48 #define EXTRA_FRAMES 128
51 pa_resample_method_t method
;
52 pa_resample_flags_t flags
;
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
;
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
;
69 pa_sample_format_t work_format
;
71 pa_convert_func_t to_work_format_func
;
72 pa_convert_func_t from_work_format_func
;
75 pa_bool_t map_required
;
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
);
82 struct { /* data specific to the trivial resampler */
87 struct { /* data specific to the peak finder pseudo resampler */
91 float max_f
[PA_CHANNELS_MAX
];
92 int16_t max_i
[PA_CHANNELS_MAX
];
96 #ifdef HAVE_LIBSAMPLERATE
97 struct { /* data specific to libsamplerate */
103 struct { /* data specific to speex */
104 SpeexResamplerState
* state
;
108 struct { /* data specific to ffmpeg */
109 struct AVResampleContext
*state
;
110 pa_memchunk buf
[PA_CHANNELS_MAX
];
114 static int copy_init(pa_resampler
*r
);
115 static int trivial_init(pa_resampler
*r
);
117 static int speex_init(pa_resampler
*r
);
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
);
125 static void calc_map_table(pa_resampler
*r
);
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
,
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
,
141 [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
,
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
,
189 [PA_RESAMPLER_FFMPEG
] = ffmpeg_init
,
190 [PA_RESAMPLER_AUTO
] = NULL
,
191 [PA_RESAMPLER_COPY
] = copy_init
,
192 [PA_RESAMPLER_PEAKS
] = peaks_init
,
195 pa_resampler
* pa_resampler_new(
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
) {
204 pa_resampler
*r
= NULL
;
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
);
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
;
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
;
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
;
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
;
236 if (method
== PA_RESAMPLER_AUTO
) {
238 method
= PA_RESAMPLER_SPEEX_FLOAT_BASE
+ 3;
240 if (flags
& PA_RESAMPLER_VARIABLE_RATE
)
241 method
= PA_RESAMPLER_TRIVIAL
;
243 method
= PA_RESAMPLER_FFMPEG
;
247 r
= pa_xnew0(pa_resampler
, 1);
252 /* Fill sample specs */
256 /* set up the remap structure */
257 r
->remap
.i_ss
= &r
->i_ss
;
258 r
->remap
.o_ss
= &r
->o_ss
;
259 r
->remap
.format
= &r
->work_format
;
263 else if (!pa_channel_map_init_auto(&r
->i_cm
, r
->i_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
))
268 else if (!pa_channel_map_init_auto(&r
->o_cm
, r
->o_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
))
271 r
->i_fz
= pa_frame_size(a
);
272 r
->o_fz
= pa_frame_size(b
);
276 pa_log_info("Using resampler '%s'", pa_resample_method_to_string(method
));
278 if ((method
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& method
<= PA_RESAMPLER_SPEEX_FIXED_MAX
) ||
279 (method
== PA_RESAMPLER_FFMPEG
))
280 r
->work_format
= PA_SAMPLE_S16NE
;
281 else if (method
== PA_RESAMPLER_TRIVIAL
|| method
== PA_RESAMPLER_COPY
|| method
== PA_RESAMPLER_PEAKS
) {
283 if (r
->map_required
|| a
->format
!= b
->format
|| method
== PA_RESAMPLER_PEAKS
) {
285 if (a
->format
== PA_SAMPLE_S16NE
|| b
->format
== PA_SAMPLE_S16NE
)
286 r
->work_format
= PA_SAMPLE_S16NE
;
287 else if (a
->format
== PA_SAMPLE_S32NE
|| a
->format
== PA_SAMPLE_S32RE
||
288 a
->format
== PA_SAMPLE_FLOAT32NE
|| a
->format
== PA_SAMPLE_FLOAT32RE
||
289 a
->format
== PA_SAMPLE_S24NE
|| a
->format
== PA_SAMPLE_S24RE
||
290 a
->format
== PA_SAMPLE_S24_32NE
|| a
->format
== PA_SAMPLE_S24_32RE
||
291 b
->format
== PA_SAMPLE_S32NE
|| b
->format
== PA_SAMPLE_S32RE
||
292 b
->format
== PA_SAMPLE_FLOAT32NE
|| b
->format
== PA_SAMPLE_FLOAT32RE
||
293 b
->format
== PA_SAMPLE_S24NE
|| b
->format
== PA_SAMPLE_S24RE
||
294 b
->format
== PA_SAMPLE_S24_32NE
|| b
->format
== PA_SAMPLE_S24_32RE
)
295 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
297 r
->work_format
= PA_SAMPLE_S16NE
;
300 r
->work_format
= a
->format
;
303 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
305 pa_log_info("Using %s as working format.", pa_sample_format_to_string(r
->work_format
));
307 r
->w_sz
= pa_sample_size_of_format(r
->work_format
);
309 if (r
->i_ss
.format
!= r
->work_format
) {
310 if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
311 if (!(r
->to_work_format_func
= pa_get_convert_to_float32ne_function(r
->i_ss
.format
)))
314 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
315 if (!(r
->to_work_format_func
= pa_get_convert_to_s16ne_function(r
->i_ss
.format
)))
320 if (r
->o_ss
.format
!= r
->work_format
) {
321 if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
322 if (!(r
->from_work_format_func
= pa_get_convert_from_float32ne_function(r
->o_ss
.format
)))
325 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
326 if (!(r
->from_work_format_func
= pa_get_convert_from_s16ne_function(r
->o_ss
.format
)))
331 /* initialize implementation */
332 if (init_table
[method
](r
) < 0)
343 void pa_resampler_free(pa_resampler
*r
) {
349 if (r
->to_work_format_buf
.memblock
)
350 pa_memblock_unref(r
->to_work_format_buf
.memblock
);
351 if (r
->remap_buf
.memblock
)
352 pa_memblock_unref(r
->remap_buf
.memblock
);
353 if (r
->resample_buf
.memblock
)
354 pa_memblock_unref(r
->resample_buf
.memblock
);
355 if (r
->from_work_format_buf
.memblock
)
356 pa_memblock_unref(r
->from_work_format_buf
.memblock
);
361 void pa_resampler_set_input_rate(pa_resampler
*r
, uint32_t rate
) {
365 if (r
->i_ss
.rate
== rate
)
370 r
->impl_update_rates(r
);
373 void pa_resampler_set_output_rate(pa_resampler
*r
, uint32_t rate
) {
377 if (r
->o_ss
.rate
== rate
)
382 r
->impl_update_rates(r
);
385 size_t pa_resampler_request(pa_resampler
*r
, size_t out_length
) {
388 /* Let's round up here to make it more likely that the caller will get at
389 * least out_length amount of data from pa_resampler_run().
391 * We don't take the leftover into account here. If we did, then it might
392 * be in theory possible that this function would return 0 and
393 * pa_resampler_run() would also return 0. That could lead to infinite
394 * loops. When the leftover is ignored here, such loops would eventually
395 * terminate, because the leftover would grow each round, finally
396 * surpassing the minimum input threshold of the resampler. */
397 return ((((uint64_t) ((out_length
+ r
->o_fz
-1) / r
->o_fz
) * r
->i_ss
.rate
) + r
->o_ss
.rate
-1) / r
->o_ss
.rate
) * r
->i_fz
;
400 size_t pa_resampler_result(pa_resampler
*r
, size_t in_length
) {
405 /* Let's round up here to ensure that the caller will always allocate big
406 * enough output buffer. */
408 frames
= (in_length
+ r
->i_fz
- 1) / r
->i_fz
;
410 if (r
->remap_buf_contains_leftover_data
)
411 frames
+= r
->remap_buf
.length
/ (r
->w_sz
* r
->o_ss
.channels
);
413 return (((uint64_t) frames
* r
->o_ss
.rate
+ r
->i_ss
.rate
- 1) / r
->i_ss
.rate
) * r
->o_fz
;
416 size_t pa_resampler_max_block_size(pa_resampler
*r
) {
417 size_t block_size_max
;
418 pa_sample_spec max_ss
;
424 block_size_max
= pa_mempool_block_size_max(r
->mempool
);
426 /* We deduce the "largest" sample spec we're using during the
428 max_ss
.channels
= (uint8_t) (PA_MAX(r
->i_ss
.channels
, r
->o_ss
.channels
));
430 /* We silently assume that the format enum is ordered by size */
431 max_ss
.format
= PA_MAX(r
->i_ss
.format
, r
->o_ss
.format
);
432 max_ss
.format
= PA_MAX(max_ss
.format
, r
->work_format
);
434 max_ss
.rate
= PA_MAX(r
->i_ss
.rate
, r
->o_ss
.rate
);
436 max_fs
= pa_frame_size(&max_ss
);
437 frames
= block_size_max
/ max_fs
- EXTRA_FRAMES
;
439 if (r
->remap_buf_contains_leftover_data
)
440 frames
-= r
->remap_buf
.length
/ (r
->w_sz
* r
->o_ss
.channels
);
442 return ((uint64_t) frames
* r
->i_ss
.rate
/ max_ss
.rate
) * r
->i_fz
;
445 void pa_resampler_reset(pa_resampler
*r
) {
451 r
->remap_buf_contains_leftover_data
= FALSE
;
454 pa_resample_method_t
pa_resampler_get_method(pa_resampler
*r
) {
460 const pa_channel_map
* pa_resampler_input_channel_map(pa_resampler
*r
) {
466 const pa_sample_spec
* pa_resampler_input_sample_spec(pa_resampler
*r
) {
472 const pa_channel_map
* pa_resampler_output_channel_map(pa_resampler
*r
) {
478 const pa_sample_spec
* pa_resampler_output_sample_spec(pa_resampler
*r
) {
484 static const char * const resample_methods
[] = {
485 "src-sinc-best-quality",
486 "src-sinc-medium-quality",
488 "src-zero-order-hold",
519 const char *pa_resample_method_to_string(pa_resample_method_t m
) {
521 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
524 return resample_methods
[m
];
527 int pa_resample_method_supported(pa_resample_method_t m
) {
529 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
532 #ifndef HAVE_LIBSAMPLERATE
533 if (m
<= PA_RESAMPLER_SRC_LINEAR
)
538 if (m
>= PA_RESAMPLER_SPEEX_FLOAT_BASE
&& m
<= PA_RESAMPLER_SPEEX_FLOAT_MAX
)
540 if (m
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& m
<= PA_RESAMPLER_SPEEX_FIXED_MAX
)
547 pa_resample_method_t
pa_parse_resample_method(const char *string
) {
548 pa_resample_method_t m
;
552 for (m
= 0; m
< PA_RESAMPLER_MAX
; m
++)
553 if (pa_streq(string
, resample_methods
[m
]))
556 if (pa_streq(string
, "speex-fixed"))
557 return PA_RESAMPLER_SPEEX_FIXED_BASE
+ 3;
559 if (pa_streq(string
, "speex-float"))
560 return PA_RESAMPLER_SPEEX_FLOAT_BASE
+ 3;
562 return PA_RESAMPLER_INVALID
;
565 static pa_bool_t
on_left(pa_channel_position_t p
) {
568 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
569 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
570 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
571 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
572 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
573 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
;
576 static pa_bool_t
on_right(pa_channel_position_t p
) {
579 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
580 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
581 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
||
582 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
583 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
584 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
;
587 static pa_bool_t
on_center(pa_channel_position_t p
) {
590 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
591 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
592 p
== PA_CHANNEL_POSITION_TOP_CENTER
||
593 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
594 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
597 static pa_bool_t
on_lfe(pa_channel_position_t p
) {
599 p
== PA_CHANNEL_POSITION_LFE
;
602 static pa_bool_t
on_front(pa_channel_position_t p
) {
604 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
605 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
606 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
607 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
608 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
609 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
610 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
611 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
;
614 static pa_bool_t
on_rear(pa_channel_position_t p
) {
616 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
617 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
618 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
619 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
||
620 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
||
621 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
624 static pa_bool_t
on_side(pa_channel_position_t p
) {
626 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
627 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
628 p
== PA_CHANNEL_POSITION_TOP_CENTER
;
638 static int front_rear_side(pa_channel_position_t p
) {
648 static void calc_map_table(pa_resampler
*r
) {
651 pa_bool_t ic_connected
[PA_CHANNELS_MAX
];
659 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
)))))
664 n_oc
= r
->o_ss
.channels
;
665 n_ic
= r
->i_ss
.channels
;
667 memset(m
->map_table_f
, 0, sizeof(m
->map_table_f
));
668 memset(m
->map_table_i
, 0, sizeof(m
->map_table_i
));
670 memset(ic_connected
, 0, sizeof(ic_connected
));
671 remix
= (r
->flags
& (PA_RESAMPLER_NO_REMAP
|PA_RESAMPLER_NO_REMIX
)) == 0;
673 for (oc
= 0; oc
< n_oc
; oc
++) {
674 pa_bool_t oc_connected
= FALSE
;
675 pa_channel_position_t b
= r
->o_cm
.map
[oc
];
677 for (ic
= 0; ic
< n_ic
; ic
++) {
678 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
680 if (r
->flags
& PA_RESAMPLER_NO_REMAP
) {
681 /* We shall not do any remapping. Hence, just check by index */
684 m
->map_table_f
[oc
][ic
] = 1.0;
689 if (r
->flags
& PA_RESAMPLER_NO_REMIX
) {
690 /* We shall not do any remixing. Hence, just check by name */
693 m
->map_table_f
[oc
][ic
] = 1.0;
700 /* OK, we shall do the full monty: upmixing and
701 * downmixing. Our algorithm is relatively simple, does
702 * not do spacialization, delay elements or apply lowpass
703 * filters for LFE. Patches are always welcome,
704 * though. Oh, and it doesn't do any matrix
705 * decoding. (Which probably wouldn't make any sense
708 * This code is not idempotent: downmixing an upmixed
709 * stereo stream is not identical to the original. The
710 * volume will not match, and the two channels will be a
711 * linear combination of both.
713 * This is loosely based on random suggestions found on the
714 * Internet, such as this:
715 * http://www.halfgaar.net/surround-sound-in-linux and the
718 * The algorithm works basically like this:
720 * 1) Connect all channels with matching names.
723 * S:Mono: Copy into all D:channels
724 * D:Mono: Avg all S:channels
726 * 3) Mix D:Left, D:Right:
727 * D:Left: If not connected, avg all S:Left
728 * D:Right: If not connected, avg all S:Right
731 * If not connected, avg all S:Center
732 * If still not connected, avg all S:Left, S:Right
735 * If not connected, avg all S:*
737 * 6) Make sure S:Left/S:Right is used: S:Left/S:Right: If
738 * not connected, mix into all D:left and all D:right
739 * channels. Gain is 0.1, the current left and right
740 * should be multiplied by 0.9.
742 * 7) Make sure S:Center, S:LFE is used:
744 * S:Center, S:LFE: If not connected, mix into all
745 * D:left, all D:right, all D:center channels, gain is
746 * 0.375. The current (as result of 1..6) factors
747 * should be multiplied by 0.75. (Alt. suggestion: 0.25
748 * vs. 0.5) If C-front is only mixed into
749 * L-front/R-front if available, otherwise into all L/R
750 * channels. Similarly for C-rear.
752 * S: and D: shall relate to the source resp. destination channels.
754 * Rationale: 1, 2 are probably obvious. For 3: this
755 * copies front to rear if needed. For 4: we try to find
756 * some suitable C source for C, if we don't find any, we
757 * avg L and R. For 5: LFE is mixed from all channels. For
758 * 6: the rear channels should not be dropped entirely,
759 * however have only minimal impact. For 7: movies usually
760 * encode speech on the center channel. Thus we have to
761 * make sure this channel is distributed to L and R if not
762 * available in the output. Also, LFE is used to achieve a
763 * greater dynamic range, and thus we should try to do our
764 * best to pass it to L+R.
767 if (a
== b
|| a
== PA_CHANNEL_POSITION_MONO
) {
768 m
->map_table_f
[oc
][ic
] = 1.0;
771 ic_connected
[ic
] = TRUE
;
773 else if (b
== PA_CHANNEL_POSITION_MONO
) {
775 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n_ic
;
778 ic_connected
[ic
] = TRUE
;
782 if (!oc_connected
&& remix
) {
783 /* OK, we shall remix */
785 /* Try to find matching input ports for this output port */
790 /* We are not connected and on the left side, let's
791 * average all left side input channels. */
793 for (ic
= 0; ic
< n_ic
; ic
++)
794 if (on_left(r
->i_cm
.map
[ic
]))
798 for (ic
= 0; ic
< n_ic
; ic
++)
799 if (on_left(r
->i_cm
.map
[ic
])) {
800 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
801 ic_connected
[ic
] = TRUE
;
804 /* We ignore the case where there is no left input
805 * channel. Something is really wrong in this case
808 } else if (on_right(b
)) {
811 /* We are not connected and on the right side, let's
812 * average all right side input channels. */
814 for (ic
= 0; ic
< n_ic
; ic
++)
815 if (on_right(r
->i_cm
.map
[ic
]))
819 for (ic
= 0; ic
< n_ic
; ic
++)
820 if (on_right(r
->i_cm
.map
[ic
])) {
821 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
822 ic_connected
[ic
] = TRUE
;
825 /* We ignore the case where there is no right input
826 * channel. Something is really wrong in this case
829 } else if (on_center(b
)) {
832 /* We are not connected and at the center. Let's
833 * average all center input channels. */
835 for (ic
= 0; ic
< n_ic
; ic
++)
836 if (on_center(r
->i_cm
.map
[ic
]))
840 for (ic
= 0; ic
< n_ic
; ic
++)
841 if (on_center(r
->i_cm
.map
[ic
])) {
842 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
843 ic_connected
[ic
] = TRUE
;
847 /* Hmm, no center channel around, let's synthesize
848 * it by mixing L and R.*/
852 for (ic
= 0; ic
< n_ic
; ic
++)
853 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
]))
857 for (ic
= 0; ic
< n_ic
; ic
++)
858 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
])) {
859 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
860 ic_connected
[ic
] = TRUE
;
863 /* We ignore the case where there is not even a
864 * left or right input channel. Something is
865 * really wrong in this case anyway. */
868 } else if (on_lfe(b
)) {
870 /* We are not connected and an LFE. Let's average all
871 * channels for LFE. */
873 for (ic
= 0; ic
< n_ic
; ic
++) {
875 if (!(r
->flags
& PA_RESAMPLER_NO_LFE
))
876 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n_ic
;
878 m
->map_table_f
[oc
][ic
] = 0;
880 /* Please note that a channel connected to LFE
881 * doesn't really count as connected. */
889 ic_unconnected_left
= 0,
890 ic_unconnected_right
= 0,
891 ic_unconnected_center
= 0,
892 ic_unconnected_lfe
= 0;
894 for (ic
= 0; ic
< n_ic
; ic
++) {
895 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
897 if (ic_connected
[ic
])
901 ic_unconnected_left
++;
902 else if (on_right(a
))
903 ic_unconnected_right
++;
904 else if (on_center(a
))
905 ic_unconnected_center
++;
907 ic_unconnected_lfe
++;
910 if (ic_unconnected_left
> 0) {
912 /* OK, so there are unconnected input channels on the
913 * left. Let's multiply all already connected channels on
914 * the left side by .9 and add in our averaged unconnected
915 * channels multiplied by .1 */
917 for (oc
= 0; oc
< n_oc
; oc
++) {
919 if (!on_left(r
->o_cm
.map
[oc
]))
922 for (ic
= 0; ic
< n_ic
; ic
++) {
924 if (ic_connected
[ic
]) {
925 m
->map_table_f
[oc
][ic
] *= .9f
;
929 if (on_left(r
->i_cm
.map
[ic
]))
930 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_left
;
935 if (ic_unconnected_right
> 0) {
937 /* OK, so there are unconnected input channels on the
938 * right. Let's multiply all already connected channels on
939 * the right side by .9 and add in our averaged unconnected
940 * channels multiplied by .1 */
942 for (oc
= 0; oc
< n_oc
; oc
++) {
944 if (!on_right(r
->o_cm
.map
[oc
]))
947 for (ic
= 0; ic
< n_ic
; ic
++) {
949 if (ic_connected
[ic
]) {
950 m
->map_table_f
[oc
][ic
] *= .9f
;
954 if (on_right(r
->i_cm
.map
[ic
]))
955 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_right
;
960 if (ic_unconnected_center
> 0) {
961 pa_bool_t mixed_in
= FALSE
;
963 /* OK, so there are unconnected input channels on the
964 * center. Let's multiply all already connected channels on
965 * the center side by .9 and add in our averaged unconnected
966 * channels multiplied by .1 */
968 for (oc
= 0; oc
< n_oc
; oc
++) {
970 if (!on_center(r
->o_cm
.map
[oc
]))
973 for (ic
= 0; ic
< n_ic
; ic
++) {
975 if (ic_connected
[ic
]) {
976 m
->map_table_f
[oc
][ic
] *= .9f
;
980 if (on_center(r
->i_cm
.map
[ic
])) {
981 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_center
;
988 unsigned ncenter
[PA_CHANNELS_MAX
];
989 pa_bool_t found_frs
[PA_CHANNELS_MAX
];
991 memset(ncenter
, 0, sizeof(ncenter
));
992 memset(found_frs
, 0, sizeof(found_frs
));
994 /* Hmm, as it appears there was no center channel we
995 could mix our center channel in. In this case, mix
996 it into left and right. Using .375 and 0.75 as
999 for (ic
= 0; ic
< n_ic
; ic
++) {
1001 if (ic_connected
[ic
])
1004 if (!on_center(r
->i_cm
.map
[ic
]))
1007 for (oc
= 0; oc
< n_oc
; oc
++) {
1009 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
1012 if (front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
])) {
1013 found_frs
[ic
] = TRUE
;
1018 for (oc
= 0; oc
< n_oc
; oc
++) {
1020 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
1023 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
1028 for (oc
= 0; oc
< n_oc
; oc
++) {
1030 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
1033 if (ncenter
[oc
] <= 0)
1036 for (ic
= 0; ic
< n_ic
; ic
++) {
1038 if (ic_connected
[ic
]) {
1039 m
->map_table_f
[oc
][ic
] *= .75f
;
1043 if (!on_center(r
->i_cm
.map
[ic
]))
1046 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
1047 m
->map_table_f
[oc
][ic
] = .375f
/ (float) ncenter
[oc
];
1053 if (ic_unconnected_lfe
> 0 && !(r
->flags
& PA_RESAMPLER_NO_LFE
)) {
1055 /* OK, so there is an unconnected LFE channel. Let's mix
1056 * it into all channels, with factor 0.375 */
1058 for (ic
= 0; ic
< n_ic
; ic
++) {
1060 if (!on_lfe(r
->i_cm
.map
[ic
]))
1063 for (oc
= 0; oc
< n_oc
; oc
++)
1064 m
->map_table_f
[oc
][ic
] = 0.375f
/ (float) ic_unconnected_lfe
;
1068 /* make an 16:16 int version of the matrix */
1069 for (oc
= 0; oc
< n_oc
; oc
++)
1070 for (ic
= 0; ic
< n_ic
; ic
++)
1071 m
->map_table_i
[oc
][ic
] = (int32_t) (m
->map_table_f
[oc
][ic
] * 0x10000);
1073 s
= pa_strbuf_new();
1075 pa_strbuf_printf(s
, " ");
1076 for (ic
= 0; ic
< n_ic
; ic
++)
1077 pa_strbuf_printf(s
, " I%02u ", ic
);
1078 pa_strbuf_puts(s
, "\n +");
1080 for (ic
= 0; ic
< n_ic
; ic
++)
1081 pa_strbuf_printf(s
, "------");
1082 pa_strbuf_puts(s
, "\n");
1084 for (oc
= 0; oc
< n_oc
; oc
++) {
1085 pa_strbuf_printf(s
, "O%02u |", oc
);
1087 for (ic
= 0; ic
< n_ic
; ic
++)
1088 pa_strbuf_printf(s
, " %1.3f", m
->map_table_f
[oc
][ic
]);
1090 pa_strbuf_puts(s
, "\n");
1093 pa_log_debug("Channel matrix:\n%s", t
= pa_strbuf_tostring_free(s
));
1096 /* initialize the remapping function */
1100 static pa_memchunk
* convert_to_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1106 pa_assert(input
->memblock
);
1108 /* Convert the incoming sample into the work sample format and place them
1109 * in to_work_format_buf. */
1111 if (!r
->to_work_format_func
|| !input
->length
)
1114 n_samples
= (unsigned) ((input
->length
/ r
->i_fz
) * r
->i_ss
.channels
);
1116 r
->to_work_format_buf
.index
= 0;
1117 r
->to_work_format_buf
.length
= r
->w_sz
* n_samples
;
1119 if (!r
->to_work_format_buf
.memblock
|| r
->to_work_format_buf_samples
< n_samples
) {
1120 if (r
->to_work_format_buf
.memblock
)
1121 pa_memblock_unref(r
->to_work_format_buf
.memblock
);
1123 r
->to_work_format_buf_samples
= n_samples
;
1124 r
->to_work_format_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->to_work_format_buf
.length
);
1127 src
= pa_memblock_acquire_chunk(input
);
1128 dst
= pa_memblock_acquire(r
->to_work_format_buf
.memblock
);
1130 r
->to_work_format_func(n_samples
, src
, dst
);
1132 pa_memblock_release(input
->memblock
);
1133 pa_memblock_release(r
->to_work_format_buf
.memblock
);
1135 return &r
->to_work_format_buf
;
1138 static pa_memchunk
*remap_channels(pa_resampler
*r
, pa_memchunk
*input
) {
1139 unsigned in_n_samples
, out_n_samples
, in_n_frames
, out_n_frames
;
1141 size_t leftover_length
= 0;
1142 pa_bool_t have_leftover
;
1146 pa_assert(input
->memblock
);
1148 /* Remap channels and place the result in remap_buf. There may be leftover
1149 * data in the beginning of remap_buf. The leftover data is already
1150 * remapped, so it's not part of the input, it's part of the output. */
1152 have_leftover
= r
->remap_buf_contains_leftover_data
;
1153 r
->remap_buf_contains_leftover_data
= FALSE
;
1155 if (!have_leftover
&& (!r
->map_required
|| input
->length
<= 0))
1157 else if (input
->length
<= 0)
1158 return &r
->remap_buf
;
1160 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1161 in_n_frames
= out_n_frames
= in_n_samples
/ r
->i_ss
.channels
;
1163 if (have_leftover
) {
1164 leftover_length
= r
->remap_buf
.length
;
1165 out_n_frames
+= leftover_length
/ (r
->w_sz
* r
->o_ss
.channels
);
1168 out_n_samples
= out_n_frames
* r
->o_ss
.channels
;
1169 r
->remap_buf
.length
= out_n_samples
* r
->w_sz
;
1171 if (have_leftover
) {
1172 if (r
->remap_buf_size
< r
->remap_buf
.length
) {
1173 pa_memblock
*new_block
= pa_memblock_new(r
->mempool
, r
->remap_buf
.length
);
1175 src
= pa_memblock_acquire(r
->remap_buf
.memblock
);
1176 dst
= pa_memblock_acquire(new_block
);
1177 memcpy(dst
, src
, leftover_length
);
1178 pa_memblock_release(r
->remap_buf
.memblock
);
1179 pa_memblock_release(new_block
);
1181 pa_memblock_unref(r
->remap_buf
.memblock
);
1182 r
->remap_buf
.memblock
= new_block
;
1183 r
->remap_buf_size
= r
->remap_buf
.length
;
1187 if (!r
->remap_buf
.memblock
|| r
->remap_buf_size
< r
->remap_buf
.length
) {
1188 if (r
->remap_buf
.memblock
)
1189 pa_memblock_unref(r
->remap_buf
.memblock
);
1191 r
->remap_buf_size
= r
->remap_buf
.length
;
1192 r
->remap_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->remap_buf
.length
);
1196 src
= pa_memblock_acquire_chunk(input
);
1197 dst
= (uint8_t *) pa_memblock_acquire(r
->remap_buf
.memblock
) + leftover_length
;
1199 if (r
->map_required
) {
1200 pa_remap_t
*remap
= &r
->remap
;
1202 pa_assert(remap
->do_remap
);
1203 remap
->do_remap(remap
, dst
, src
, in_n_frames
);
1206 memcpy(dst
, src
, input
->length
);
1208 pa_memblock_release(input
->memblock
);
1209 pa_memblock_release(r
->remap_buf
.memblock
);
1211 return &r
->remap_buf
;
1214 static pa_memchunk
*resample(pa_resampler
*r
, pa_memchunk
*input
) {
1215 unsigned in_n_frames
, in_n_samples
;
1216 unsigned out_n_frames
, out_n_samples
;
1221 /* Resample the data and place the result in resample_buf. */
1223 if (!r
->impl_resample
|| !input
->length
)
1226 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1227 in_n_frames
= (unsigned) (in_n_samples
/ r
->o_ss
.channels
);
1229 out_n_frames
= ((in_n_frames
*r
->o_ss
.rate
)/r
->i_ss
.rate
)+EXTRA_FRAMES
;
1230 out_n_samples
= out_n_frames
* r
->o_ss
.channels
;
1232 r
->resample_buf
.index
= 0;
1233 r
->resample_buf
.length
= r
->w_sz
* out_n_samples
;
1235 if (!r
->resample_buf
.memblock
|| r
->resample_buf_samples
< out_n_samples
) {
1236 if (r
->resample_buf
.memblock
)
1237 pa_memblock_unref(r
->resample_buf
.memblock
);
1239 r
->resample_buf_samples
= out_n_samples
;
1240 r
->resample_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->resample_buf
.length
);
1243 r
->impl_resample(r
, input
, in_n_frames
, &r
->resample_buf
, &out_n_frames
);
1244 r
->resample_buf
.length
= out_n_frames
* r
->w_sz
* r
->o_ss
.channels
;
1246 return &r
->resample_buf
;
1249 static pa_memchunk
*convert_from_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1250 unsigned n_samples
, n_frames
;
1256 /* Convert the data into the correct sample type and place the result in
1257 * from_work_format_buf. */
1259 if (!r
->from_work_format_func
|| !input
->length
)
1262 n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1263 n_frames
= n_samples
/ r
->o_ss
.channels
;
1265 r
->from_work_format_buf
.index
= 0;
1266 r
->from_work_format_buf
.length
= r
->o_fz
* n_frames
;
1268 if (!r
->from_work_format_buf
.memblock
|| r
->from_work_format_buf_samples
< n_samples
) {
1269 if (r
->from_work_format_buf
.memblock
)
1270 pa_memblock_unref(r
->from_work_format_buf
.memblock
);
1272 r
->from_work_format_buf_samples
= n_samples
;
1273 r
->from_work_format_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->from_work_format_buf
.length
);
1276 src
= pa_memblock_acquire_chunk(input
);
1277 dst
= pa_memblock_acquire(r
->from_work_format_buf
.memblock
);
1278 r
->from_work_format_func(n_samples
, src
, dst
);
1279 pa_memblock_release(input
->memblock
);
1280 pa_memblock_release(r
->from_work_format_buf
.memblock
);
1282 return &r
->from_work_format_buf
;
1285 void pa_resampler_run(pa_resampler
*r
, const pa_memchunk
*in
, pa_memchunk
*out
) {
1291 pa_assert(in
->length
);
1292 pa_assert(in
->memblock
);
1293 pa_assert(in
->length
% r
->i_fz
== 0);
1295 buf
= (pa_memchunk
*) in
;
1296 buf
= convert_to_work_format(r
, buf
);
1297 buf
= remap_channels(r
, buf
);
1298 buf
= resample(r
, buf
);
1301 buf
= convert_from_work_format(r
, buf
);
1305 pa_memblock_ref(buf
->memblock
);
1307 pa_memchunk_reset(buf
);
1309 pa_memchunk_reset(out
);
1312 static void save_leftover(pa_resampler
*r
, void *buf
, size_t len
) {
1319 /* Store the leftover to remap_buf. */
1321 r
->remap_buf
.length
= len
;
1323 if (!r
->remap_buf
.memblock
|| r
->remap_buf_size
< r
->remap_buf
.length
) {
1324 if (r
->remap_buf
.memblock
)
1325 pa_memblock_unref(r
->remap_buf
.memblock
);
1327 r
->remap_buf_size
= r
->remap_buf
.length
;
1328 r
->remap_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->remap_buf
.length
);
1331 dst
= pa_memblock_acquire(r
->remap_buf
.memblock
);
1332 memcpy(dst
, buf
, r
->remap_buf
.length
);
1333 pa_memblock_release(r
->remap_buf
.memblock
);
1335 r
->remap_buf_contains_leftover_data
= TRUE
;
1338 /*** libsamplerate based implementation ***/
1340 #ifdef HAVE_LIBSAMPLERATE
1341 static void libsamplerate_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1347 pa_assert(out_n_frames
);
1349 memset(&data
, 0, sizeof(data
));
1351 data
.data_in
= pa_memblock_acquire_chunk(input
);
1352 data
.input_frames
= (long int) in_n_frames
;
1354 data
.data_out
= pa_memblock_acquire_chunk(output
);
1355 data
.output_frames
= (long int) *out_n_frames
;
1357 data
.src_ratio
= (double) r
->o_ss
.rate
/ r
->i_ss
.rate
;
1358 data
.end_of_input
= 0;
1360 pa_assert_se(src_process(r
->src
.state
, &data
) == 0);
1362 if (data
.input_frames_used
< in_n_frames
) {
1363 void *leftover_data
= data
.data_in
+ data
.input_frames_used
* r
->o_ss
.channels
;
1364 size_t leftover_length
= (in_n_frames
- data
.input_frames_used
) * sizeof(float) * r
->o_ss
.channels
;
1366 save_leftover(r
, leftover_data
, leftover_length
);
1369 pa_memblock_release(input
->memblock
);
1370 pa_memblock_release(output
->memblock
);
1372 *out_n_frames
= (unsigned) data
.output_frames_gen
;
1375 static void libsamplerate_update_rates(pa_resampler
*r
) {
1378 pa_assert_se(src_set_ratio(r
->src
.state
, (double) r
->o_ss
.rate
/ r
->i_ss
.rate
) == 0);
1381 static void libsamplerate_reset(pa_resampler
*r
) {
1384 pa_assert_se(src_reset(r
->src
.state
) == 0);
1387 static void libsamplerate_free(pa_resampler
*r
) {
1391 src_delete(r
->src
.state
);
1394 static int libsamplerate_init(pa_resampler
*r
) {
1399 if (!(r
->src
.state
= src_new(r
->method
, r
->o_ss
.channels
, &err
)))
1402 r
->impl_free
= libsamplerate_free
;
1403 r
->impl_update_rates
= libsamplerate_update_rates
;
1404 r
->impl_resample
= libsamplerate_resample
;
1405 r
->impl_reset
= libsamplerate_reset
;
1412 /*** speex based implementation ***/
1414 static void speex_resample_float(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1416 uint32_t inf
= in_n_frames
, outf
= *out_n_frames
;
1421 pa_assert(out_n_frames
);
1423 in
= pa_memblock_acquire_chunk(input
);
1424 out
= pa_memblock_acquire_chunk(output
);
1426 pa_assert_se(speex_resampler_process_interleaved_float(r
->speex
.state
, in
, &inf
, out
, &outf
) == 0);
1428 pa_memblock_release(input
->memblock
);
1429 pa_memblock_release(output
->memblock
);
1431 pa_assert(inf
== in_n_frames
);
1432 *out_n_frames
= outf
;
1435 static void speex_resample_int(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1437 uint32_t inf
= in_n_frames
, outf
= *out_n_frames
;
1442 pa_assert(out_n_frames
);
1444 in
= pa_memblock_acquire_chunk(input
);
1445 out
= pa_memblock_acquire_chunk(output
);
1447 pa_assert_se(speex_resampler_process_interleaved_int(r
->speex
.state
, in
, &inf
, out
, &outf
) == 0);
1449 pa_memblock_release(input
->memblock
);
1450 pa_memblock_release(output
->memblock
);
1452 pa_assert(inf
== in_n_frames
);
1453 *out_n_frames
= outf
;
1456 static void speex_update_rates(pa_resampler
*r
) {
1459 pa_assert_se(speex_resampler_set_rate(r
->speex
.state
, r
->i_ss
.rate
, r
->o_ss
.rate
) == 0);
1462 static void speex_reset(pa_resampler
*r
) {
1465 pa_assert_se(speex_resampler_reset_mem(r
->speex
.state
) == 0);
1468 static void speex_free(pa_resampler
*r
) {
1471 if (!r
->speex
.state
)
1474 speex_resampler_destroy(r
->speex
.state
);
1477 static int speex_init(pa_resampler
*r
) {
1482 r
->impl_free
= speex_free
;
1483 r
->impl_update_rates
= speex_update_rates
;
1484 r
->impl_reset
= speex_reset
;
1486 if (r
->method
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& r
->method
<= PA_RESAMPLER_SPEEX_FIXED_MAX
) {
1488 q
= r
->method
- PA_RESAMPLER_SPEEX_FIXED_BASE
;
1489 r
->impl_resample
= speex_resample_int
;
1492 pa_assert(r
->method
>= PA_RESAMPLER_SPEEX_FLOAT_BASE
&& r
->method
<= PA_RESAMPLER_SPEEX_FLOAT_MAX
);
1494 q
= r
->method
- PA_RESAMPLER_SPEEX_FLOAT_BASE
;
1495 r
->impl_resample
= speex_resample_float
;
1498 pa_log_info("Choosing speex quality setting %i.", q
);
1500 if (!(r
->speex
.state
= speex_resampler_init(r
->o_ss
.channels
, r
->i_ss
.rate
, r
->o_ss
.rate
, q
, &err
)))
1507 /* Trivial implementation */
1509 static void trivial_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1511 unsigned i_index
, o_index
;
1517 pa_assert(out_n_frames
);
1519 fz
= r
->w_sz
* r
->o_ss
.channels
;
1521 src
= pa_memblock_acquire_chunk(input
);
1522 dst
= pa_memblock_acquire_chunk(output
);
1524 for (o_index
= 0;; o_index
++, r
->trivial
.o_counter
++) {
1525 i_index
= ((uint64_t) r
->trivial
.o_counter
* r
->i_ss
.rate
) / r
->o_ss
.rate
;
1526 i_index
= i_index
> r
->trivial
.i_counter
? i_index
- r
->trivial
.i_counter
: 0;
1528 if (i_index
>= in_n_frames
)
1531 pa_assert_fp(o_index
* fz
< pa_memblock_get_length(output
->memblock
));
1533 memcpy((uint8_t*) dst
+ fz
* o_index
, (uint8_t*) src
+ fz
* i_index
, (int) fz
);
1536 pa_memblock_release(input
->memblock
);
1537 pa_memblock_release(output
->memblock
);
1539 *out_n_frames
= o_index
;
1541 r
->trivial
.i_counter
+= in_n_frames
;
1543 /* Normalize counters */
1544 while (r
->trivial
.i_counter
>= r
->i_ss
.rate
) {
1545 pa_assert(r
->trivial
.o_counter
>= r
->o_ss
.rate
);
1547 r
->trivial
.i_counter
-= r
->i_ss
.rate
;
1548 r
->trivial
.o_counter
-= r
->o_ss
.rate
;
1552 static void trivial_update_rates_or_reset(pa_resampler
*r
) {
1555 r
->trivial
.i_counter
= 0;
1556 r
->trivial
.o_counter
= 0;
1559 static int trivial_init(pa_resampler
*r
) {
1562 r
->trivial
.o_counter
= r
->trivial
.i_counter
= 0;
1564 r
->impl_resample
= trivial_resample
;
1565 r
->impl_update_rates
= trivial_update_rates_or_reset
;
1566 r
->impl_reset
= trivial_update_rates_or_reset
;
1571 /* Peak finder implementation */
1573 static void peaks_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1574 unsigned c
, o_index
= 0;
1575 unsigned i
, i_end
= 0;
1581 pa_assert(out_n_frames
);
1583 src
= pa_memblock_acquire_chunk(input
);
1584 dst
= pa_memblock_acquire_chunk(output
);
1586 i
= ((uint64_t) r
->peaks
.o_counter
* r
->i_ss
.rate
) / r
->o_ss
.rate
;
1587 i
= i
> r
->peaks
.i_counter
? i
- r
->peaks
.i_counter
: 0;
1589 while (i_end
< in_n_frames
) {
1590 i_end
= ((uint64_t) (r
->peaks
.o_counter
+ 1) * r
->i_ss
.rate
) / r
->o_ss
.rate
;
1591 i_end
= i_end
> r
->peaks
.i_counter
? i_end
- r
->peaks
.i_counter
: 0;
1593 pa_assert_fp(o_index
* r
->w_sz
* r
->o_ss
.channels
< pa_memblock_get_length(output
->memblock
));
1595 /* 1ch float is treated separately, because that is the common case */
1596 if (r
->o_ss
.channels
== 1 && r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
1597 float *s
= (float*) src
+ i
;
1598 float *d
= (float*) dst
+ o_index
;
1600 for (; i
< i_end
&& i
< in_n_frames
; i
++) {
1601 float n
= fabsf(*s
++);
1603 if (n
> r
->peaks
.max_f
[0])
1604 r
->peaks
.max_f
[0] = n
;
1608 *d
= r
->peaks
.max_f
[0];
1609 r
->peaks
.max_f
[0] = 0;
1610 o_index
++, r
->peaks
.o_counter
++;
1612 } else if (r
->work_format
== PA_SAMPLE_S16NE
) {
1613 int16_t *s
= (int16_t*) src
+ r
->i_ss
.channels
* i
;
1614 int16_t *d
= (int16_t*) dst
+ r
->o_ss
.channels
* o_index
;
1616 for (; i
< i_end
&& i
< in_n_frames
; i
++)
1617 for (c
= 0; c
< r
->o_ss
.channels
; c
++) {
1618 int16_t n
= abs(*s
++);
1620 if (n
> r
->peaks
.max_i
[c
])
1621 r
->peaks
.max_i
[c
] = n
;
1625 for (c
= 0; c
< r
->o_ss
.channels
; c
++, d
++) {
1626 *d
= r
->peaks
.max_i
[c
];
1627 r
->peaks
.max_i
[c
] = 0;
1629 o_index
++, r
->peaks
.o_counter
++;
1632 float *s
= (float*) src
+ r
->i_ss
.channels
* i
;
1633 float *d
= (float*) dst
+ r
->o_ss
.channels
* o_index
;
1635 for (; i
< i_end
&& i
< in_n_frames
; i
++)
1636 for (c
= 0; c
< r
->o_ss
.channels
; c
++) {
1637 float n
= fabsf(*s
++);
1639 if (n
> r
->peaks
.max_f
[c
])
1640 r
->peaks
.max_f
[c
] = n
;
1644 for (c
= 0; c
< r
->o_ss
.channels
; c
++, d
++) {
1645 *d
= r
->peaks
.max_f
[c
];
1646 r
->peaks
.max_f
[c
] = 0;
1648 o_index
++, r
->peaks
.o_counter
++;
1653 pa_memblock_release(input
->memblock
);
1654 pa_memblock_release(output
->memblock
);
1656 *out_n_frames
= o_index
;
1658 r
->peaks
.i_counter
+= in_n_frames
;
1660 /* Normalize counters */
1661 while (r
->peaks
.i_counter
>= r
->i_ss
.rate
) {
1662 pa_assert(r
->peaks
.o_counter
>= r
->o_ss
.rate
);
1664 r
->peaks
.i_counter
-= r
->i_ss
.rate
;
1665 r
->peaks
.o_counter
-= r
->o_ss
.rate
;
1669 static void peaks_update_rates_or_reset(pa_resampler
*r
) {
1672 r
->peaks
.i_counter
= 0;
1673 r
->peaks
.o_counter
= 0;
1676 static int peaks_init(pa_resampler
*r
) {
1678 pa_assert(r
->i_ss
.rate
>= r
->o_ss
.rate
);
1679 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
|| r
->work_format
== PA_SAMPLE_FLOAT32NE
);
1681 r
->peaks
.o_counter
= r
->peaks
.i_counter
= 0;
1682 memset(r
->peaks
.max_i
, 0, sizeof(r
->peaks
.max_i
));
1683 memset(r
->peaks
.max_f
, 0, sizeof(r
->peaks
.max_f
));
1685 r
->impl_resample
= peaks_resample
;
1686 r
->impl_update_rates
= peaks_update_rates_or_reset
;
1687 r
->impl_reset
= peaks_update_rates_or_reset
;
1692 /*** ffmpeg based implementation ***/
1694 static void ffmpeg_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1695 unsigned used_frames
= 0, c
;
1696 int previous_consumed_frames
= -1;
1701 pa_assert(out_n_frames
);
1703 for (c
= 0; c
< r
->o_ss
.channels
; c
++) {
1706 int16_t *p
, *t
, *k
, *q
, *s
;
1707 int consumed_frames
;
1709 /* Allocate a new block */
1710 b
= pa_memblock_new(r
->mempool
, r
->ffmpeg
.buf
[c
].length
+ in_n_frames
* sizeof(int16_t));
1711 p
= pa_memblock_acquire(b
);
1713 /* Now copy the input data, splitting up channels */
1714 t
= (int16_t*) pa_memblock_acquire_chunk(input
) + c
;
1716 for (u
= 0; u
< in_n_frames
; u
++) {
1718 t
+= r
->o_ss
.channels
;
1721 pa_memblock_release(input
->memblock
);
1723 /* Allocate buffer for the result */
1724 w
= pa_memblock_new(r
->mempool
, *out_n_frames
* sizeof(int16_t));
1725 q
= pa_memblock_acquire(w
);
1728 used_frames
= (unsigned) av_resample(r
->ffmpeg
.state
,
1731 (int) in_n_frames
, (int) *out_n_frames
,
1732 c
>= (unsigned) (r
->o_ss
.channels
-1));
1734 pa_memblock_release(b
);
1735 pa_memblock_unref(b
);
1737 pa_assert(consumed_frames
<= (int) in_n_frames
);
1738 pa_assert(previous_consumed_frames
== -1 || consumed_frames
== previous_consumed_frames
);
1739 previous_consumed_frames
= consumed_frames
;
1741 /* And place the results in the output buffer */
1742 s
= (int16_t *) pa_memblock_acquire_chunk(output
) + c
;
1743 for (u
= 0; u
< used_frames
; u
++) {
1746 s
+= r
->o_ss
.channels
;
1748 pa_memblock_release(output
->memblock
);
1749 pa_memblock_release(w
);
1750 pa_memblock_unref(w
);
1753 if (previous_consumed_frames
< (int) in_n_frames
) {
1754 void *leftover_data
= (int16_t *) pa_memblock_acquire_chunk(input
) + previous_consumed_frames
* r
->o_ss
.channels
;
1755 size_t leftover_length
= (in_n_frames
- previous_consumed_frames
) * r
->o_ss
.channels
* sizeof(int16_t);
1757 save_leftover(r
, leftover_data
, leftover_length
);
1758 pa_memblock_release(input
->memblock
);
1761 *out_n_frames
= used_frames
;
1764 static void ffmpeg_free(pa_resampler
*r
) {
1769 if (r
->ffmpeg
.state
)
1770 av_resample_close(r
->ffmpeg
.state
);
1772 for (c
= 0; c
< PA_ELEMENTSOF(r
->ffmpeg
.buf
); c
++)
1773 if (r
->ffmpeg
.buf
[c
].memblock
)
1774 pa_memblock_unref(r
->ffmpeg
.buf
[c
].memblock
);
1777 static int ffmpeg_init(pa_resampler
*r
) {
1782 /* We could probably implement different quality levels by
1783 * adjusting the filter parameters here. However, ffmpeg
1784 * internally only uses these hardcoded values, so let's use them
1785 * here for now as well until ffmpeg makes this configurable. */
1787 if (!(r
->ffmpeg
.state
= av_resample_init((int) r
->o_ss
.rate
, (int) r
->i_ss
.rate
, 16, 10, 0, 0.8)))
1790 r
->impl_free
= ffmpeg_free
;
1791 r
->impl_resample
= ffmpeg_resample
;
1793 for (c
= 0; c
< PA_ELEMENTSOF(r
->ffmpeg
.buf
); c
++)
1794 pa_memchunk_reset(&r
->ffmpeg
.buf
[c
]);
1799 /*** copy (noop) implementation ***/
1801 static int copy_init(pa_resampler
*r
) {
1804 pa_assert(r
->o_ss
.rate
== r
->i_ss
.rate
);