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_S32NE
|| a
->format
== PA_SAMPLE_S32RE
||
286 a
->format
== PA_SAMPLE_FLOAT32NE
|| a
->format
== PA_SAMPLE_FLOAT32RE
||
287 a
->format
== PA_SAMPLE_S24NE
|| a
->format
== PA_SAMPLE_S24RE
||
288 a
->format
== PA_SAMPLE_S24_32NE
|| a
->format
== PA_SAMPLE_S24_32RE
||
289 b
->format
== PA_SAMPLE_S32NE
|| b
->format
== PA_SAMPLE_S32RE
||
290 b
->format
== PA_SAMPLE_FLOAT32NE
|| b
->format
== PA_SAMPLE_FLOAT32RE
||
291 b
->format
== PA_SAMPLE_S24NE
|| b
->format
== PA_SAMPLE_S24RE
||
292 b
->format
== PA_SAMPLE_S24_32NE
|| b
->format
== PA_SAMPLE_S24_32RE
)
293 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
295 r
->work_format
= PA_SAMPLE_S16NE
;
298 r
->work_format
= a
->format
;
301 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
303 pa_log_info("Using %s as working format.", pa_sample_format_to_string(r
->work_format
));
305 r
->w_sz
= pa_sample_size_of_format(r
->work_format
);
307 if (r
->i_ss
.format
!= r
->work_format
) {
308 if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
309 if (!(r
->to_work_format_func
= pa_get_convert_to_float32ne_function(r
->i_ss
.format
)))
312 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
313 if (!(r
->to_work_format_func
= pa_get_convert_to_s16ne_function(r
->i_ss
.format
)))
318 if (r
->o_ss
.format
!= r
->work_format
) {
319 if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
320 if (!(r
->from_work_format_func
= pa_get_convert_from_float32ne_function(r
->o_ss
.format
)))
323 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
324 if (!(r
->from_work_format_func
= pa_get_convert_from_s16ne_function(r
->o_ss
.format
)))
329 /* initialize implementation */
330 if (init_table
[method
](r
) < 0)
341 void pa_resampler_free(pa_resampler
*r
) {
347 if (r
->to_work_format_buf
.memblock
)
348 pa_memblock_unref(r
->to_work_format_buf
.memblock
);
349 if (r
->remap_buf
.memblock
)
350 pa_memblock_unref(r
->remap_buf
.memblock
);
351 if (r
->resample_buf
.memblock
)
352 pa_memblock_unref(r
->resample_buf
.memblock
);
353 if (r
->from_work_format_buf
.memblock
)
354 pa_memblock_unref(r
->from_work_format_buf
.memblock
);
359 void pa_resampler_set_input_rate(pa_resampler
*r
, uint32_t rate
) {
363 if (r
->i_ss
.rate
== rate
)
368 r
->impl_update_rates(r
);
371 void pa_resampler_set_output_rate(pa_resampler
*r
, uint32_t rate
) {
375 if (r
->o_ss
.rate
== rate
)
380 r
->impl_update_rates(r
);
383 size_t pa_resampler_request(pa_resampler
*r
, size_t out_length
) {
386 /* Let's round up here to make it more likely that the caller will get at
387 * least out_length amount of data from pa_resampler_run().
389 * We don't take the leftover into account here. If we did, then it might
390 * be in theory possible that this function would return 0 and
391 * pa_resampler_run() would also return 0. That could lead to infinite
392 * loops. When the leftover is ignored here, such loops would eventually
393 * terminate, because the leftover would grow each round, finally
394 * surpassing the minimum input threshold of the resampler. */
395 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
;
398 size_t pa_resampler_result(pa_resampler
*r
, size_t in_length
) {
403 /* Let's round up here to ensure that the caller will always allocate big
404 * enough output buffer. */
406 frames
= (in_length
+ r
->i_fz
- 1) / r
->i_fz
;
408 if (r
->remap_buf_contains_leftover_data
)
409 frames
+= r
->remap_buf
.length
/ (r
->w_sz
* r
->o_ss
.channels
);
411 return (((uint64_t) frames
* r
->o_ss
.rate
+ r
->i_ss
.rate
- 1) / r
->i_ss
.rate
) * r
->o_fz
;
414 size_t pa_resampler_max_block_size(pa_resampler
*r
) {
415 size_t block_size_max
;
416 pa_sample_spec max_ss
;
422 block_size_max
= pa_mempool_block_size_max(r
->mempool
);
424 /* We deduce the "largest" sample spec we're using during the
426 max_ss
.channels
= (uint8_t) (PA_MAX(r
->i_ss
.channels
, r
->o_ss
.channels
));
428 /* We silently assume that the format enum is ordered by size */
429 max_ss
.format
= PA_MAX(r
->i_ss
.format
, r
->o_ss
.format
);
430 max_ss
.format
= PA_MAX(max_ss
.format
, r
->work_format
);
432 max_ss
.rate
= PA_MAX(r
->i_ss
.rate
, r
->o_ss
.rate
);
434 max_fs
= pa_frame_size(&max_ss
);
435 frames
= block_size_max
/ max_fs
- EXTRA_FRAMES
;
437 if (r
->remap_buf_contains_leftover_data
)
438 frames
-= r
->remap_buf
.length
/ (r
->w_sz
* r
->o_ss
.channels
);
440 return ((uint64_t) frames
* r
->i_ss
.rate
/ max_ss
.rate
) * r
->i_fz
;
443 void pa_resampler_reset(pa_resampler
*r
) {
449 r
->remap_buf_contains_leftover_data
= FALSE
;
452 pa_resample_method_t
pa_resampler_get_method(pa_resampler
*r
) {
458 const pa_channel_map
* pa_resampler_input_channel_map(pa_resampler
*r
) {
464 const pa_sample_spec
* pa_resampler_input_sample_spec(pa_resampler
*r
) {
470 const pa_channel_map
* pa_resampler_output_channel_map(pa_resampler
*r
) {
476 const pa_sample_spec
* pa_resampler_output_sample_spec(pa_resampler
*r
) {
482 static const char * const resample_methods
[] = {
483 "src-sinc-best-quality",
484 "src-sinc-medium-quality",
486 "src-zero-order-hold",
517 const char *pa_resample_method_to_string(pa_resample_method_t m
) {
519 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
522 return resample_methods
[m
];
525 int pa_resample_method_supported(pa_resample_method_t m
) {
527 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
530 #ifndef HAVE_LIBSAMPLERATE
531 if (m
<= PA_RESAMPLER_SRC_LINEAR
)
536 if (m
>= PA_RESAMPLER_SPEEX_FLOAT_BASE
&& m
<= PA_RESAMPLER_SPEEX_FLOAT_MAX
)
538 if (m
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& m
<= PA_RESAMPLER_SPEEX_FIXED_MAX
)
545 pa_resample_method_t
pa_parse_resample_method(const char *string
) {
546 pa_resample_method_t m
;
550 for (m
= 0; m
< PA_RESAMPLER_MAX
; m
++)
551 if (pa_streq(string
, resample_methods
[m
]))
554 if (pa_streq(string
, "speex-fixed"))
555 return PA_RESAMPLER_SPEEX_FIXED_BASE
+ 3;
557 if (pa_streq(string
, "speex-float"))
558 return PA_RESAMPLER_SPEEX_FLOAT_BASE
+ 3;
560 return PA_RESAMPLER_INVALID
;
563 static pa_bool_t
on_left(pa_channel_position_t p
) {
566 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
567 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
568 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
569 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
570 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
571 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
;
574 static pa_bool_t
on_right(pa_channel_position_t p
) {
577 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
578 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
579 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
||
580 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
581 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
582 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
;
585 static pa_bool_t
on_center(pa_channel_position_t p
) {
588 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
589 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
590 p
== PA_CHANNEL_POSITION_TOP_CENTER
||
591 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
592 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
595 static pa_bool_t
on_lfe(pa_channel_position_t p
) {
597 p
== PA_CHANNEL_POSITION_LFE
;
600 static pa_bool_t
on_front(pa_channel_position_t p
) {
602 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
603 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
604 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
605 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
606 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
607 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
608 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
609 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
;
612 static pa_bool_t
on_rear(pa_channel_position_t p
) {
614 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
615 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
616 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
617 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
||
618 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
||
619 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
622 static pa_bool_t
on_side(pa_channel_position_t p
) {
624 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
625 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
626 p
== PA_CHANNEL_POSITION_TOP_CENTER
;
636 static int front_rear_side(pa_channel_position_t p
) {
646 static void calc_map_table(pa_resampler
*r
) {
649 pa_bool_t ic_connected
[PA_CHANNELS_MAX
];
657 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
)))))
662 n_oc
= r
->o_ss
.channels
;
663 n_ic
= r
->i_ss
.channels
;
665 memset(m
->map_table_f
, 0, sizeof(m
->map_table_f
));
666 memset(m
->map_table_i
, 0, sizeof(m
->map_table_i
));
668 memset(ic_connected
, 0, sizeof(ic_connected
));
669 remix
= (r
->flags
& (PA_RESAMPLER_NO_REMAP
|PA_RESAMPLER_NO_REMIX
)) == 0;
671 for (oc
= 0; oc
< n_oc
; oc
++) {
672 pa_bool_t oc_connected
= FALSE
;
673 pa_channel_position_t b
= r
->o_cm
.map
[oc
];
675 for (ic
= 0; ic
< n_ic
; ic
++) {
676 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
678 if (r
->flags
& PA_RESAMPLER_NO_REMAP
) {
679 /* We shall not do any remapping. Hence, just check by index */
682 m
->map_table_f
[oc
][ic
] = 1.0;
687 if (r
->flags
& PA_RESAMPLER_NO_REMIX
) {
688 /* We shall not do any remixing. Hence, just check by name */
691 m
->map_table_f
[oc
][ic
] = 1.0;
698 /* OK, we shall do the full monty: upmixing and
699 * downmixing. Our algorithm is relatively simple, does
700 * not do spacialization, delay elements or apply lowpass
701 * filters for LFE. Patches are always welcome,
702 * though. Oh, and it doesn't do any matrix
703 * decoding. (Which probably wouldn't make any sense
706 * This code is not idempotent: downmixing an upmixed
707 * stereo stream is not identical to the original. The
708 * volume will not match, and the two channels will be a
709 * linear combination of both.
711 * This is loosely based on random suggestions found on the
712 * Internet, such as this:
713 * http://www.halfgaar.net/surround-sound-in-linux and the
716 * The algorithm works basically like this:
718 * 1) Connect all channels with matching names.
721 * S:Mono: Copy into all D:channels
722 * D:Mono: Avg all S:channels
724 * 3) Mix D:Left, D:Right:
725 * D:Left: If not connected, avg all S:Left
726 * D:Right: If not connected, avg all S:Right
729 * If not connected, avg all S:Center
730 * If still not connected, avg all S:Left, S:Right
733 * If not connected, avg all S:*
735 * 6) Make sure S:Left/S:Right is used: S:Left/S:Right: If
736 * not connected, mix into all D:left and all D:right
737 * channels. Gain is 0.1, the current left and right
738 * should be multiplied by 0.9.
740 * 7) Make sure S:Center, S:LFE is used:
742 * S:Center, S:LFE: If not connected, mix into all
743 * D:left, all D:right, all D:center channels, gain is
744 * 0.375. The current (as result of 1..6) factors
745 * should be multiplied by 0.75. (Alt. suggestion: 0.25
746 * vs. 0.5) If C-front is only mixed into
747 * L-front/R-front if available, otherwise into all L/R
748 * channels. Similarly for C-rear.
750 * S: and D: shall relate to the source resp. destination channels.
752 * Rationale: 1, 2 are probably obvious. For 3: this
753 * copies front to rear if needed. For 4: we try to find
754 * some suitable C source for C, if we don't find any, we
755 * avg L and R. For 5: LFE is mixed from all channels. For
756 * 6: the rear channels should not be dropped entirely,
757 * however have only minimal impact. For 7: movies usually
758 * encode speech on the center channel. Thus we have to
759 * make sure this channel is distributed to L and R if not
760 * available in the output. Also, LFE is used to achieve a
761 * greater dynamic range, and thus we should try to do our
762 * best to pass it to L+R.
765 if (a
== b
|| a
== PA_CHANNEL_POSITION_MONO
) {
766 m
->map_table_f
[oc
][ic
] = 1.0;
769 ic_connected
[ic
] = TRUE
;
771 else if (b
== PA_CHANNEL_POSITION_MONO
) {
773 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n_ic
;
776 ic_connected
[ic
] = TRUE
;
780 if (!oc_connected
&& remix
) {
781 /* OK, we shall remix */
783 /* Try to find matching input ports for this output port */
788 /* We are not connected and on the left side, let's
789 * average all left side input channels. */
791 for (ic
= 0; ic
< n_ic
; ic
++)
792 if (on_left(r
->i_cm
.map
[ic
]))
796 for (ic
= 0; ic
< n_ic
; ic
++)
797 if (on_left(r
->i_cm
.map
[ic
])) {
798 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
799 ic_connected
[ic
] = TRUE
;
802 /* We ignore the case where there is no left input
803 * channel. Something is really wrong in this case
806 } else if (on_right(b
)) {
809 /* We are not connected and on the right side, let's
810 * average all right side input channels. */
812 for (ic
= 0; ic
< n_ic
; ic
++)
813 if (on_right(r
->i_cm
.map
[ic
]))
817 for (ic
= 0; ic
< n_ic
; ic
++)
818 if (on_right(r
->i_cm
.map
[ic
])) {
819 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
820 ic_connected
[ic
] = TRUE
;
823 /* We ignore the case where there is no right input
824 * channel. Something is really wrong in this case
827 } else if (on_center(b
)) {
830 /* We are not connected and at the center. Let's
831 * average all center input channels. */
833 for (ic
= 0; ic
< n_ic
; ic
++)
834 if (on_center(r
->i_cm
.map
[ic
]))
838 for (ic
= 0; ic
< n_ic
; ic
++)
839 if (on_center(r
->i_cm
.map
[ic
])) {
840 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
841 ic_connected
[ic
] = TRUE
;
845 /* Hmm, no center channel around, let's synthesize
846 * it by mixing L and R.*/
850 for (ic
= 0; ic
< n_ic
; ic
++)
851 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
]))
855 for (ic
= 0; ic
< n_ic
; ic
++)
856 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
])) {
857 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n
;
858 ic_connected
[ic
] = TRUE
;
861 /* We ignore the case where there is not even a
862 * left or right input channel. Something is
863 * really wrong in this case anyway. */
866 } else if (on_lfe(b
)) {
868 /* We are not connected and an LFE. Let's average all
869 * channels for LFE. */
871 for (ic
= 0; ic
< n_ic
; ic
++) {
873 if (!(r
->flags
& PA_RESAMPLER_NO_LFE
))
874 m
->map_table_f
[oc
][ic
] = 1.0f
/ (float) n_ic
;
876 m
->map_table_f
[oc
][ic
] = 0;
878 /* Please note that a channel connected to LFE
879 * doesn't really count as connected. */
887 ic_unconnected_left
= 0,
888 ic_unconnected_right
= 0,
889 ic_unconnected_center
= 0,
890 ic_unconnected_lfe
= 0;
892 for (ic
= 0; ic
< n_ic
; ic
++) {
893 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
895 if (ic_connected
[ic
])
899 ic_unconnected_left
++;
900 else if (on_right(a
))
901 ic_unconnected_right
++;
902 else if (on_center(a
))
903 ic_unconnected_center
++;
905 ic_unconnected_lfe
++;
908 if (ic_unconnected_left
> 0) {
910 /* OK, so there are unconnected input channels on the
911 * left. Let's multiply all already connected channels on
912 * the left side by .9 and add in our averaged unconnected
913 * channels multiplied by .1 */
915 for (oc
= 0; oc
< n_oc
; oc
++) {
917 if (!on_left(r
->o_cm
.map
[oc
]))
920 for (ic
= 0; ic
< n_ic
; ic
++) {
922 if (ic_connected
[ic
]) {
923 m
->map_table_f
[oc
][ic
] *= .9f
;
927 if (on_left(r
->i_cm
.map
[ic
]))
928 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_left
;
933 if (ic_unconnected_right
> 0) {
935 /* OK, so there are unconnected input channels on the
936 * right. Let's multiply all already connected channels on
937 * the right side by .9 and add in our averaged unconnected
938 * channels multiplied by .1 */
940 for (oc
= 0; oc
< n_oc
; oc
++) {
942 if (!on_right(r
->o_cm
.map
[oc
]))
945 for (ic
= 0; ic
< n_ic
; ic
++) {
947 if (ic_connected
[ic
]) {
948 m
->map_table_f
[oc
][ic
] *= .9f
;
952 if (on_right(r
->i_cm
.map
[ic
]))
953 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_right
;
958 if (ic_unconnected_center
> 0) {
959 pa_bool_t mixed_in
= FALSE
;
961 /* OK, so there are unconnected input channels on the
962 * center. Let's multiply all already connected channels on
963 * the center side by .9 and add in our averaged unconnected
964 * channels multiplied by .1 */
966 for (oc
= 0; oc
< n_oc
; oc
++) {
968 if (!on_center(r
->o_cm
.map
[oc
]))
971 for (ic
= 0; ic
< n_ic
; ic
++) {
973 if (ic_connected
[ic
]) {
974 m
->map_table_f
[oc
][ic
] *= .9f
;
978 if (on_center(r
->i_cm
.map
[ic
])) {
979 m
->map_table_f
[oc
][ic
] = .1f
/ (float) ic_unconnected_center
;
986 unsigned ncenter
[PA_CHANNELS_MAX
];
987 pa_bool_t found_frs
[PA_CHANNELS_MAX
];
989 memset(ncenter
, 0, sizeof(ncenter
));
990 memset(found_frs
, 0, sizeof(found_frs
));
992 /* Hmm, as it appears there was no center channel we
993 could mix our center channel in. In this case, mix
994 it into left and right. Using .375 and 0.75 as
997 for (ic
= 0; ic
< n_ic
; ic
++) {
999 if (ic_connected
[ic
])
1002 if (!on_center(r
->i_cm
.map
[ic
]))
1005 for (oc
= 0; oc
< n_oc
; oc
++) {
1007 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
1010 if (front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
])) {
1011 found_frs
[ic
] = TRUE
;
1016 for (oc
= 0; oc
< n_oc
; oc
++) {
1018 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
1021 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
1026 for (oc
= 0; oc
< n_oc
; oc
++) {
1028 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
1031 if (ncenter
[oc
] <= 0)
1034 for (ic
= 0; ic
< n_ic
; ic
++) {
1036 if (ic_connected
[ic
]) {
1037 m
->map_table_f
[oc
][ic
] *= .75f
;
1041 if (!on_center(r
->i_cm
.map
[ic
]))
1044 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
1045 m
->map_table_f
[oc
][ic
] = .375f
/ (float) ncenter
[oc
];
1051 if (ic_unconnected_lfe
> 0 && !(r
->flags
& PA_RESAMPLER_NO_LFE
)) {
1053 /* OK, so there is an unconnected LFE channel. Let's mix
1054 * it into all channels, with factor 0.375 */
1056 for (ic
= 0; ic
< n_ic
; ic
++) {
1058 if (!on_lfe(r
->i_cm
.map
[ic
]))
1061 for (oc
= 0; oc
< n_oc
; oc
++)
1062 m
->map_table_f
[oc
][ic
] = 0.375f
/ (float) ic_unconnected_lfe
;
1066 /* make an 16:16 int version of the matrix */
1067 for (oc
= 0; oc
< n_oc
; oc
++)
1068 for (ic
= 0; ic
< n_ic
; ic
++)
1069 m
->map_table_i
[oc
][ic
] = (int32_t) (m
->map_table_f
[oc
][ic
] * 0x10000);
1071 s
= pa_strbuf_new();
1073 pa_strbuf_printf(s
, " ");
1074 for (ic
= 0; ic
< n_ic
; ic
++)
1075 pa_strbuf_printf(s
, " I%02u ", ic
);
1076 pa_strbuf_puts(s
, "\n +");
1078 for (ic
= 0; ic
< n_ic
; ic
++)
1079 pa_strbuf_printf(s
, "------");
1080 pa_strbuf_puts(s
, "\n");
1082 for (oc
= 0; oc
< n_oc
; oc
++) {
1083 pa_strbuf_printf(s
, "O%02u |", oc
);
1085 for (ic
= 0; ic
< n_ic
; ic
++)
1086 pa_strbuf_printf(s
, " %1.3f", m
->map_table_f
[oc
][ic
]);
1088 pa_strbuf_puts(s
, "\n");
1091 pa_log_debug("Channel matrix:\n%s", t
= pa_strbuf_tostring_free(s
));
1094 /* initialize the remapping function */
1098 static pa_memchunk
* convert_to_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1104 pa_assert(input
->memblock
);
1106 /* Convert the incoming sample into the work sample format and place them
1107 * in to_work_format_buf. */
1109 if (!r
->to_work_format_func
|| !input
->length
)
1112 n_samples
= (unsigned) ((input
->length
/ r
->i_fz
) * r
->i_ss
.channels
);
1114 r
->to_work_format_buf
.index
= 0;
1115 r
->to_work_format_buf
.length
= r
->w_sz
* n_samples
;
1117 if (!r
->to_work_format_buf
.memblock
|| r
->to_work_format_buf_samples
< n_samples
) {
1118 if (r
->to_work_format_buf
.memblock
)
1119 pa_memblock_unref(r
->to_work_format_buf
.memblock
);
1121 r
->to_work_format_buf_samples
= n_samples
;
1122 r
->to_work_format_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->to_work_format_buf
.length
);
1125 src
= pa_memblock_acquire_chunk(input
);
1126 dst
= pa_memblock_acquire(r
->to_work_format_buf
.memblock
);
1128 r
->to_work_format_func(n_samples
, src
, dst
);
1130 pa_memblock_release(input
->memblock
);
1131 pa_memblock_release(r
->to_work_format_buf
.memblock
);
1133 return &r
->to_work_format_buf
;
1136 static pa_memchunk
*remap_channels(pa_resampler
*r
, pa_memchunk
*input
) {
1137 unsigned in_n_samples
, out_n_samples
, in_n_frames
, out_n_frames
;
1139 size_t leftover_length
= 0;
1140 pa_bool_t have_leftover
;
1144 pa_assert(input
->memblock
);
1146 /* Remap channels and place the result in remap_buf. There may be leftover
1147 * data in the beginning of remap_buf. The leftover data is already
1148 * remapped, so it's not part of the input, it's part of the output. */
1150 have_leftover
= r
->remap_buf_contains_leftover_data
;
1151 r
->remap_buf_contains_leftover_data
= FALSE
;
1153 if (!have_leftover
&& (!r
->map_required
|| input
->length
<= 0))
1155 else if (input
->length
<= 0)
1156 return &r
->remap_buf
;
1158 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1159 in_n_frames
= out_n_frames
= in_n_samples
/ r
->i_ss
.channels
;
1161 if (have_leftover
) {
1162 leftover_length
= r
->remap_buf
.length
;
1163 out_n_frames
+= leftover_length
/ (r
->w_sz
* r
->o_ss
.channels
);
1166 out_n_samples
= out_n_frames
* r
->o_ss
.channels
;
1167 r
->remap_buf
.length
= out_n_samples
* r
->w_sz
;
1169 if (have_leftover
) {
1170 if (r
->remap_buf_size
< r
->remap_buf
.length
) {
1171 pa_memblock
*new_block
= pa_memblock_new(r
->mempool
, r
->remap_buf
.length
);
1173 src
= pa_memblock_acquire(r
->remap_buf
.memblock
);
1174 dst
= pa_memblock_acquire(new_block
);
1175 memcpy(dst
, src
, leftover_length
);
1176 pa_memblock_release(r
->remap_buf
.memblock
);
1177 pa_memblock_release(new_block
);
1179 pa_memblock_unref(r
->remap_buf
.memblock
);
1180 r
->remap_buf
.memblock
= new_block
;
1181 r
->remap_buf_size
= r
->remap_buf
.length
;
1185 if (!r
->remap_buf
.memblock
|| r
->remap_buf_size
< r
->remap_buf
.length
) {
1186 if (r
->remap_buf
.memblock
)
1187 pa_memblock_unref(r
->remap_buf
.memblock
);
1189 r
->remap_buf_size
= r
->remap_buf
.length
;
1190 r
->remap_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->remap_buf
.length
);
1194 src
= pa_memblock_acquire_chunk(input
);
1195 dst
= (uint8_t *) pa_memblock_acquire(r
->remap_buf
.memblock
) + leftover_length
;
1197 if (r
->map_required
) {
1198 pa_remap_t
*remap
= &r
->remap
;
1200 pa_assert(remap
->do_remap
);
1201 remap
->do_remap(remap
, dst
, src
, in_n_frames
);
1204 memcpy(dst
, src
, input
->length
);
1206 pa_memblock_release(input
->memblock
);
1207 pa_memblock_release(r
->remap_buf
.memblock
);
1209 return &r
->remap_buf
;
1212 static pa_memchunk
*resample(pa_resampler
*r
, pa_memchunk
*input
) {
1213 unsigned in_n_frames
, in_n_samples
;
1214 unsigned out_n_frames
, out_n_samples
;
1219 /* Resample the data and place the result in resample_buf. */
1221 if (!r
->impl_resample
|| !input
->length
)
1224 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1225 in_n_frames
= (unsigned) (in_n_samples
/ r
->o_ss
.channels
);
1227 out_n_frames
= ((in_n_frames
*r
->o_ss
.rate
)/r
->i_ss
.rate
)+EXTRA_FRAMES
;
1228 out_n_samples
= out_n_frames
* r
->o_ss
.channels
;
1230 r
->resample_buf
.index
= 0;
1231 r
->resample_buf
.length
= r
->w_sz
* out_n_samples
;
1233 if (!r
->resample_buf
.memblock
|| r
->resample_buf_samples
< out_n_samples
) {
1234 if (r
->resample_buf
.memblock
)
1235 pa_memblock_unref(r
->resample_buf
.memblock
);
1237 r
->resample_buf_samples
= out_n_samples
;
1238 r
->resample_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->resample_buf
.length
);
1241 r
->impl_resample(r
, input
, in_n_frames
, &r
->resample_buf
, &out_n_frames
);
1242 r
->resample_buf
.length
= out_n_frames
* r
->w_sz
* r
->o_ss
.channels
;
1244 return &r
->resample_buf
;
1247 static pa_memchunk
*convert_from_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1248 unsigned n_samples
, n_frames
;
1254 /* Convert the data into the correct sample type and place the result in
1255 * from_work_format_buf. */
1257 if (!r
->from_work_format_func
|| !input
->length
)
1260 n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1261 n_frames
= n_samples
/ r
->o_ss
.channels
;
1263 r
->from_work_format_buf
.index
= 0;
1264 r
->from_work_format_buf
.length
= r
->o_fz
* n_frames
;
1266 if (!r
->from_work_format_buf
.memblock
|| r
->from_work_format_buf_samples
< n_samples
) {
1267 if (r
->from_work_format_buf
.memblock
)
1268 pa_memblock_unref(r
->from_work_format_buf
.memblock
);
1270 r
->from_work_format_buf_samples
= n_samples
;
1271 r
->from_work_format_buf
.memblock
= pa_memblock_new(r
->mempool
, r
->from_work_format_buf
.length
);
1274 src
= pa_memblock_acquire_chunk(input
);
1275 dst
= pa_memblock_acquire(r
->from_work_format_buf
.memblock
);
1276 r
->from_work_format_func(n_samples
, src
, dst
);
1277 pa_memblock_release(input
->memblock
);
1278 pa_memblock_release(r
->from_work_format_buf
.memblock
);
1280 r
->from_work_format_buf
.length
= r
->o_fz
* n_frames
;
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
);