2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2.1 of the License,
9 or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
28 #ifdef HAVE_LIBSAMPLERATE
29 #include <samplerate.h>
32 #include <speex/speex_resampler.h>
34 #include <pulse/xmalloc.h>
35 #include <pulsecore/sconv.h>
36 #include <pulsecore/log.h>
37 #include <pulsecore/macro.h>
38 #include <pulsecore/strbuf.h>
40 #include "ffmpeg/avcodec.h"
42 #include "resampler.h"
44 /* Number of samples of extra space we allow the resamplers to return */
45 #define EXTRA_FRAMES 128
48 pa_resample_method_t method
;
49 pa_resample_flags_t flags
;
51 pa_sample_spec i_ss
, o_ss
;
52 pa_channel_map i_cm
, o_cm
;
53 size_t i_fz
, o_fz
, w_sz
;
56 pa_memchunk buf1
, buf2
, buf3
, buf4
;
57 unsigned buf1_samples
, buf2_samples
, buf3_samples
, buf4_samples
;
59 pa_sample_format_t work_format
;
61 pa_convert_func_t to_work_format_func
;
62 pa_convert_func_t from_work_format_func
;
64 float map_table
[PA_CHANNELS_MAX
][PA_CHANNELS_MAX
];
65 pa_bool_t map_required
;
67 void (*impl_free
)(pa_resampler
*r
);
68 void (*impl_update_rates
)(pa_resampler
*r
);
69 void (*impl_resample
)(pa_resampler
*r
, const pa_memchunk
*in
, unsigned in_samples
, pa_memchunk
*out
, unsigned *out_samples
);
70 void (*impl_reset
)(pa_resampler
*r
);
72 struct { /* data specific to the trivial resampler */
77 struct { /* data specific to the peak finder pseudo resampler */
81 float max_f
[PA_CHANNELS_MAX
];
82 int16_t max_i
[PA_CHANNELS_MAX
];
86 #ifdef HAVE_LIBSAMPLERATE
87 struct { /* data specific to libsamplerate */
92 struct { /* data specific to speex */
93 SpeexResamplerState
* state
;
96 struct { /* data specific to ffmpeg */
97 struct AVResampleContext
*state
;
98 pa_memchunk buf
[PA_CHANNELS_MAX
];
102 static int copy_init(pa_resampler
*r
);
103 static int trivial_init(pa_resampler
*r
);
104 static int speex_init(pa_resampler
*r
);
105 static int ffmpeg_init(pa_resampler
*r
);
106 static int peaks_init(pa_resampler
*r
);
107 #ifdef HAVE_LIBSAMPLERATE
108 static int libsamplerate_init(pa_resampler
*r
);
111 static void calc_map_table(pa_resampler
*r
);
113 static int (* const init_table
[])(pa_resampler
*r
) = {
114 #ifdef HAVE_LIBSAMPLERATE
115 [PA_RESAMPLER_SRC_SINC_BEST_QUALITY
] = libsamplerate_init
,
116 [PA_RESAMPLER_SRC_SINC_MEDIUM_QUALITY
] = libsamplerate_init
,
117 [PA_RESAMPLER_SRC_SINC_FASTEST
] = libsamplerate_init
,
118 [PA_RESAMPLER_SRC_ZERO_ORDER_HOLD
] = libsamplerate_init
,
119 [PA_RESAMPLER_SRC_LINEAR
] = libsamplerate_init
,
121 [PA_RESAMPLER_SRC_SINC_BEST_QUALITY
] = NULL
,
122 [PA_RESAMPLER_SRC_SINC_MEDIUM_QUALITY
] = NULL
,
123 [PA_RESAMPLER_SRC_SINC_FASTEST
] = NULL
,
124 [PA_RESAMPLER_SRC_ZERO_ORDER_HOLD
] = NULL
,
125 [PA_RESAMPLER_SRC_LINEAR
] = NULL
,
127 [PA_RESAMPLER_TRIVIAL
] = trivial_init
,
128 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+0] = speex_init
,
129 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+1] = speex_init
,
130 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+2] = speex_init
,
131 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+3] = speex_init
,
132 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+4] = speex_init
,
133 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+5] = speex_init
,
134 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+6] = speex_init
,
135 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+7] = speex_init
,
136 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+8] = speex_init
,
137 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+9] = speex_init
,
138 [PA_RESAMPLER_SPEEX_FLOAT_BASE
+10] = speex_init
,
139 [PA_RESAMPLER_SPEEX_FIXED_BASE
+0] = speex_init
,
140 [PA_RESAMPLER_SPEEX_FIXED_BASE
+1] = speex_init
,
141 [PA_RESAMPLER_SPEEX_FIXED_BASE
+2] = speex_init
,
142 [PA_RESAMPLER_SPEEX_FIXED_BASE
+3] = speex_init
,
143 [PA_RESAMPLER_SPEEX_FIXED_BASE
+4] = speex_init
,
144 [PA_RESAMPLER_SPEEX_FIXED_BASE
+5] = speex_init
,
145 [PA_RESAMPLER_SPEEX_FIXED_BASE
+6] = speex_init
,
146 [PA_RESAMPLER_SPEEX_FIXED_BASE
+7] = speex_init
,
147 [PA_RESAMPLER_SPEEX_FIXED_BASE
+8] = speex_init
,
148 [PA_RESAMPLER_SPEEX_FIXED_BASE
+9] = speex_init
,
149 [PA_RESAMPLER_SPEEX_FIXED_BASE
+10] = speex_init
,
150 [PA_RESAMPLER_FFMPEG
] = ffmpeg_init
,
151 [PA_RESAMPLER_AUTO
] = NULL
,
152 [PA_RESAMPLER_COPY
] = copy_init
,
153 [PA_RESAMPLER_PEAKS
] = peaks_init
,
156 pa_resampler
* pa_resampler_new(
158 const pa_sample_spec
*a
,
159 const pa_channel_map
*am
,
160 const pa_sample_spec
*b
,
161 const pa_channel_map
*bm
,
162 pa_resample_method_t method
,
163 pa_resample_flags_t flags
) {
165 pa_resampler
*r
= NULL
;
170 pa_assert(pa_sample_spec_valid(a
));
171 pa_assert(pa_sample_spec_valid(b
));
172 pa_assert(method
>= 0);
173 pa_assert(method
< PA_RESAMPLER_MAX
);
177 if (!(flags
& PA_RESAMPLER_VARIABLE_RATE
) && a
->rate
== b
->rate
) {
178 pa_log_info("Forcing resampler 'copy', because of fixed, identical sample rates.");
179 method
= PA_RESAMPLER_COPY
;
182 if (!pa_resample_method_supported(method
)) {
183 pa_log_warn("Support for resampler '%s' not compiled in, reverting to 'auto'.", pa_resample_method_to_string(method
));
184 method
= PA_RESAMPLER_AUTO
;
187 if (method
== PA_RESAMPLER_FFMPEG
&& (flags
& PA_RESAMPLER_VARIABLE_RATE
)) {
188 pa_log_info("Resampler 'ffmpeg' cannot do variable rate, reverting to resampler 'auto'.");
189 method
= PA_RESAMPLER_AUTO
;
192 if (method
== PA_RESAMPLER_COPY
&& ((flags
& PA_RESAMPLER_VARIABLE_RATE
) || a
->rate
!= b
->rate
)) {
193 pa_log_info("Resampler 'copy' cannot change sampling rate, reverting to resampler 'auto'.");
194 method
= PA_RESAMPLER_AUTO
;
197 if (method
== PA_RESAMPLER_AUTO
)
198 method
= PA_RESAMPLER_SPEEX_FLOAT_BASE
+ 3;
200 r
= pa_xnew(pa_resampler
, 1);
206 r
->impl_update_rates
= NULL
;
207 r
->impl_resample
= NULL
;
208 r
->impl_reset
= NULL
;
210 /* Fill sample specs */
216 else if (!pa_channel_map_init_auto(&r
->i_cm
, r
->i_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
))
221 else if (!pa_channel_map_init_auto(&r
->o_cm
, r
->o_ss
.channels
, PA_CHANNEL_MAP_DEFAULT
))
224 r
->i_fz
= pa_frame_size(a
);
225 r
->o_fz
= pa_frame_size(b
);
227 pa_memchunk_reset(&r
->buf1
);
228 pa_memchunk_reset(&r
->buf2
);
229 pa_memchunk_reset(&r
->buf3
);
230 pa_memchunk_reset(&r
->buf4
);
232 r
->buf1_samples
= r
->buf2_samples
= r
->buf3_samples
= r
->buf4_samples
= 0;
236 pa_log_info("Using resampler '%s'", pa_resample_method_to_string(method
));
238 if ((method
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& method
<= PA_RESAMPLER_SPEEX_FIXED_MAX
) ||
239 (method
== PA_RESAMPLER_FFMPEG
))
240 r
->work_format
= PA_SAMPLE_S16NE
;
241 else if (method
== PA_RESAMPLER_TRIVIAL
|| method
== PA_RESAMPLER_COPY
|| method
== PA_RESAMPLER_PEAKS
) {
243 if (r
->map_required
|| a
->format
!= b
->format
|| method
== PA_RESAMPLER_PEAKS
) {
245 if (a
->format
== PA_SAMPLE_S32NE
|| a
->format
== PA_SAMPLE_S32RE
||
246 a
->format
== PA_SAMPLE_FLOAT32NE
|| a
->format
== PA_SAMPLE_FLOAT32RE
||
247 a
->format
== PA_SAMPLE_S24NE
|| a
->format
== PA_SAMPLE_S24RE
||
248 a
->format
== PA_SAMPLE_S24_32NE
|| a
->format
== PA_SAMPLE_S24_32RE
||
249 b
->format
== PA_SAMPLE_S32NE
|| b
->format
== PA_SAMPLE_S32RE
||
250 b
->format
== PA_SAMPLE_FLOAT32NE
|| b
->format
== PA_SAMPLE_FLOAT32RE
||
251 b
->format
== PA_SAMPLE_S24NE
|| b
->format
== PA_SAMPLE_S24RE
||
252 b
->format
== PA_SAMPLE_S24_32NE
|| b
->format
== PA_SAMPLE_S24_32RE
)
253 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
255 r
->work_format
= PA_SAMPLE_S16NE
;
258 r
->work_format
= a
->format
;
261 r
->work_format
= PA_SAMPLE_FLOAT32NE
;
263 pa_log_info("Using %s as working format.", pa_sample_format_to_string(r
->work_format
));
265 r
->w_sz
= pa_sample_size_of_format(r
->work_format
);
267 if (r
->i_ss
.format
== r
->work_format
)
268 r
->to_work_format_func
= NULL
;
269 else if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
270 if (!(r
->to_work_format_func
= pa_get_convert_to_float32ne_function(r
->i_ss
.format
)))
273 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
274 if (!(r
->to_work_format_func
= pa_get_convert_to_s16ne_function(r
->i_ss
.format
)))
278 if (r
->o_ss
.format
== r
->work_format
)
279 r
->from_work_format_func
= NULL
;
280 else if (r
->work_format
== PA_SAMPLE_FLOAT32NE
) {
281 if (!(r
->from_work_format_func
= pa_get_convert_from_float32ne_function(r
->o_ss
.format
)))
284 pa_assert(r
->work_format
== PA_SAMPLE_S16NE
);
285 if (!(r
->from_work_format_func
= pa_get_convert_from_s16ne_function(r
->o_ss
.format
)))
289 /* initialize implementation */
290 if (init_table
[method
](r
) < 0)
302 void pa_resampler_free(pa_resampler
*r
) {
308 if (r
->buf1
.memblock
)
309 pa_memblock_unref(r
->buf1
.memblock
);
310 if (r
->buf2
.memblock
)
311 pa_memblock_unref(r
->buf2
.memblock
);
312 if (r
->buf3
.memblock
)
313 pa_memblock_unref(r
->buf3
.memblock
);
314 if (r
->buf4
.memblock
)
315 pa_memblock_unref(r
->buf4
.memblock
);
320 void pa_resampler_set_input_rate(pa_resampler
*r
, uint32_t rate
) {
324 if (r
->i_ss
.rate
== rate
)
329 r
->impl_update_rates(r
);
332 void pa_resampler_set_output_rate(pa_resampler
*r
, uint32_t rate
) {
336 if (r
->o_ss
.rate
== rate
)
341 r
->impl_update_rates(r
);
344 size_t pa_resampler_request(pa_resampler
*r
, size_t out_length
) {
347 /* Let's round up here */
349 return (((((out_length
+ r
->o_fz
-1) / r
->o_fz
) * r
->i_ss
.rate
) + r
->o_ss
.rate
-1) / r
->o_ss
.rate
) * r
->i_fz
;
352 size_t pa_resampler_result(pa_resampler
*r
, size_t in_length
) {
355 /* Let's round up here */
357 return (((((in_length
+ r
->i_fz
-1) / r
->i_fz
) * r
->o_ss
.rate
) + r
->i_ss
.rate
-1) / r
->i_ss
.rate
) * r
->o_fz
;
360 size_t pa_resampler_max_block_size(pa_resampler
*r
) {
361 size_t block_size_max
;
367 block_size_max
= pa_mempool_block_size_max(r
->mempool
);
369 /* We deduce the "largest" sample spec we're using during the
371 ss
.channels
= (uint8_t) (PA_MAX(r
->i_ss
.channels
, r
->o_ss
.channels
));
373 /* We silently assume that the format enum is ordered by size */
374 ss
.format
= PA_MAX(r
->i_ss
.format
, r
->o_ss
.format
);
375 ss
.format
= PA_MAX(ss
.format
, r
->work_format
);
377 ss
.rate
= PA_MAX(r
->i_ss
.rate
, r
->o_ss
.rate
);
379 fs
= pa_frame_size(&ss
);
381 return (((block_size_max
/fs
- EXTRA_FRAMES
)*r
->i_ss
.rate
)/ss
.rate
)*r
->i_fz
;
384 void pa_resampler_reset(pa_resampler
*r
) {
391 pa_resample_method_t
pa_resampler_get_method(pa_resampler
*r
) {
397 const pa_channel_map
* pa_resampler_input_channel_map(pa_resampler
*r
) {
403 const pa_sample_spec
* pa_resampler_input_sample_spec(pa_resampler
*r
) {
409 const pa_channel_map
* pa_resampler_output_channel_map(pa_resampler
*r
) {
415 const pa_sample_spec
* pa_resampler_output_sample_spec(pa_resampler
*r
) {
421 static const char * const resample_methods
[] = {
422 "src-sinc-best-quality",
423 "src-sinc-medium-quality",
425 "src-zero-order-hold",
456 const char *pa_resample_method_to_string(pa_resample_method_t m
) {
458 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
461 return resample_methods
[m
];
464 int pa_resample_method_supported(pa_resample_method_t m
) {
466 if (m
< 0 || m
>= PA_RESAMPLER_MAX
)
469 #ifndef HAVE_LIBSAMPLERATE
470 if (m
<= PA_RESAMPLER_SRC_LINEAR
)
477 pa_resample_method_t
pa_parse_resample_method(const char *string
) {
478 pa_resample_method_t m
;
482 for (m
= 0; m
< PA_RESAMPLER_MAX
; m
++)
483 if (!strcmp(string
, resample_methods
[m
]))
486 if (!strcmp(string
, "speex-fixed"))
487 return PA_RESAMPLER_SPEEX_FIXED_BASE
+ 3;
489 if (!strcmp(string
, "speex-float"))
490 return PA_RESAMPLER_SPEEX_FLOAT_BASE
+ 3;
492 return PA_RESAMPLER_INVALID
;
495 static pa_bool_t
on_left(pa_channel_position_t p
) {
498 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
499 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
500 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
501 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
502 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
503 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
;
506 static pa_bool_t
on_right(pa_channel_position_t p
) {
509 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
510 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
511 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
||
512 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
513 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
514 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
;
517 static pa_bool_t
on_center(pa_channel_position_t p
) {
520 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
521 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
522 p
== PA_CHANNEL_POSITION_TOP_CENTER
||
523 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
524 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
527 static pa_bool_t
on_lfe(pa_channel_position_t p
) {
529 p
== PA_CHANNEL_POSITION_LFE
;
532 static pa_bool_t
on_front(pa_channel_position_t p
) {
534 p
== PA_CHANNEL_POSITION_FRONT_LEFT
||
535 p
== PA_CHANNEL_POSITION_FRONT_RIGHT
||
536 p
== PA_CHANNEL_POSITION_FRONT_CENTER
||
537 p
== PA_CHANNEL_POSITION_TOP_FRONT_LEFT
||
538 p
== PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
||
539 p
== PA_CHANNEL_POSITION_TOP_FRONT_CENTER
||
540 p
== PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
||
541 p
== PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
;
544 static pa_bool_t
on_rear(pa_channel_position_t p
) {
546 p
== PA_CHANNEL_POSITION_REAR_LEFT
||
547 p
== PA_CHANNEL_POSITION_REAR_RIGHT
||
548 p
== PA_CHANNEL_POSITION_REAR_CENTER
||
549 p
== PA_CHANNEL_POSITION_TOP_REAR_LEFT
||
550 p
== PA_CHANNEL_POSITION_TOP_REAR_RIGHT
||
551 p
== PA_CHANNEL_POSITION_TOP_REAR_CENTER
;
554 static pa_bool_t
on_side(pa_channel_position_t p
) {
556 p
== PA_CHANNEL_POSITION_SIDE_LEFT
||
557 p
== PA_CHANNEL_POSITION_SIDE_RIGHT
||
558 p
== PA_CHANNEL_POSITION_TOP_CENTER
;
568 static int front_rear_side(pa_channel_position_t p
) {
578 static void calc_map_table(pa_resampler
*r
) {
580 pa_bool_t ic_connected
[PA_CHANNELS_MAX
];
587 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
)))))
590 memset(r
->map_table
, 0, sizeof(r
->map_table
));
591 memset(ic_connected
, 0, sizeof(ic_connected
));
592 remix
= (r
->flags
& (PA_RESAMPLER_NO_REMAP
|PA_RESAMPLER_NO_REMIX
)) == 0;
594 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
595 pa_bool_t oc_connected
= FALSE
;
596 pa_channel_position_t b
= r
->o_cm
.map
[oc
];
598 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
599 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
601 if (r
->flags
& PA_RESAMPLER_NO_REMAP
) {
602 /* We shall not do any remapping. Hence, just check by index */
605 r
->map_table
[oc
][ic
] = 1.0;
610 if (r
->flags
& PA_RESAMPLER_NO_REMIX
) {
611 /* We shall not do any remixing. Hence, just check by name */
614 r
->map_table
[oc
][ic
] = 1.0;
621 /* OK, we shall do the full monty: upmixing and
622 * downmixing. Our algorithm is relatively simple, does
623 * not do spacialization, delay elements or apply lowpass
624 * filters for LFE. Patches are always welcome,
625 * though. Oh, and it doesn't do any matrix
626 * decoding. (Which probably wouldn't make any sense
629 * This code is not idempotent: downmixing an upmixed
630 * stereo stream is not identical to the original. The
631 * volume will not match, and the two channels will be a
632 * linear combination of both.
634 * This is losely based on random suggestions found on the
635 * Internet, such as this:
636 * http://www.halfgaar.net/surround-sound-in-linux and the
639 * The algorithm works basically like this:
641 * 1) Connect all channels with matching names.
644 * S:Mono: Copy into all D:channels
645 * D:Mono: Copy in all S:channels
647 * 3) Mix D:Left, D:Right:
648 * D:Left: If not connected, avg all S:Left
649 * D:Right: If not connected, avg all S:Right
652 * If not connected, avg all S:Center
653 * If still not connected, avg all S:Left, S:Right
656 * If not connected, avg all S:*
658 * 6) Make sure S:Left/S:Right is used: S:Left/S:Right: If
659 * not connected, mix into all D:left and all D:right
660 * channels. Gain is 0.1, the current left and right
661 * should be multiplied by 0.9.
663 * 7) Make sure S:Center, S:LFE is used:
665 * S:Center, S:LFE: If not connected, mix into all
666 * D:left, all D:right, all D:center channels, gain is
667 * 0.375. The current (as result of 1..6) factors
668 * should be multiplied by 0.75. (Alt. suggestion: 0.25
669 * vs. 0.5) If C-front is only mixed into
670 * L-front/R-front if available, otherwise into all L/R
671 * channels. Similarly for C-rear.
673 * S: and D: shall relate to the source resp. destination channels.
675 * Rationale: 1, 2 are probably obvious. For 3: this
676 * copies front to rear if needed. For 4: we try to find
677 * some suitable C source for C, if we don't find any, we
678 * avg L and R. For 5: LFE is mixed from all channels. For
679 * 6: the rear channels should not be dropped entirely,
680 * however have only minimal impact. For 7: movies usually
681 * encode speech on the center channel. Thus we have to
682 * make sure this channel is distributed to L and R if not
683 * available in the output. Also, LFE is used to achieve a
684 * greater dynamic range, and thus we should try to do our
685 * best to pass it to L+R.
688 if (a
== b
|| a
== PA_CHANNEL_POSITION_MONO
|| b
== PA_CHANNEL_POSITION_MONO
) {
689 r
->map_table
[oc
][ic
] = 1.0;
692 ic_connected
[ic
] = TRUE
;
696 if (!oc_connected
&& remix
) {
697 /* OK, we shall remix */
699 /* Try to find matching input ports for this output port */
704 /* We are not connected and on the left side, let's
705 * average all left side input channels. */
707 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
708 if (on_left(r
->i_cm
.map
[ic
]))
712 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
713 if (on_left(r
->i_cm
.map
[ic
])) {
714 r
->map_table
[oc
][ic
] = 1.0f
/ (float) n
;
715 ic_connected
[ic
] = TRUE
;
718 /* We ignore the case where there is no left input
719 * channel. Something is really wrong in this case
722 } else if (on_right(b
)) {
725 /* We are not connected and on the right side, let's
726 * average all right side input channels. */
728 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
729 if (on_right(r
->i_cm
.map
[ic
]))
733 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
734 if (on_right(r
->i_cm
.map
[ic
])) {
735 r
->map_table
[oc
][ic
] = 1.0f
/ (float) n
;
736 ic_connected
[ic
] = TRUE
;
739 /* We ignore the case where there is no right input
740 * channel. Something is really wrong in this case
743 } else if (on_center(b
)) {
746 /* We are not connected and at the center. Let's
747 * average all center input channels. */
749 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
750 if (on_center(r
->i_cm
.map
[ic
]))
754 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
755 if (on_center(r
->i_cm
.map
[ic
])) {
756 r
->map_table
[oc
][ic
] = 1.0f
/ (float) n
;
757 ic_connected
[ic
] = TRUE
;
761 /* Hmm, no center channel around, let's synthesize
762 * it by mixing L and R.*/
766 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
767 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
]))
771 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
772 if (on_left(r
->i_cm
.map
[ic
]) || on_right(r
->i_cm
.map
[ic
])) {
773 r
->map_table
[oc
][ic
] = 1.0f
/ (float) n
;
774 ic_connected
[ic
] = TRUE
;
777 /* We ignore the case where there is not even a
778 * left or right input channel. Something is
779 * really wrong in this case anyway. */
782 } else if (on_lfe(b
)) {
784 /* We are not connected and an LFE. Let's average all
785 * channels for LFE. */
787 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
789 if (!(r
->flags
& PA_RESAMPLER_NO_LFE
))
790 r
->map_table
[oc
][ic
] = 1.0f
/ (float) r
->i_ss
.channels
;
792 r
->map_table
[oc
][ic
] = 0;
794 /* Please note that a channel connected to LFE
795 * doesn't really count as connected. */
803 ic_unconnected_left
= 0,
804 ic_unconnected_right
= 0,
805 ic_unconnected_center
= 0,
806 ic_unconnected_lfe
= 0;
808 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
809 pa_channel_position_t a
= r
->i_cm
.map
[ic
];
811 if (ic_connected
[ic
])
815 ic_unconnected_left
++;
816 else if (on_right(a
))
817 ic_unconnected_right
++;
818 else if (on_center(a
))
819 ic_unconnected_center
++;
821 ic_unconnected_lfe
++;
824 if (ic_unconnected_left
> 0) {
826 /* OK, so there are unconnected input channels on the
827 * left. Let's multiply all already connected channels on
828 * the left side by .9 and add in our averaged unconnected
829 * channels multplied by .1 */
831 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
833 if (!on_left(r
->o_cm
.map
[oc
]))
836 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
838 if (ic_connected
[ic
]) {
839 r
->map_table
[oc
][ic
] *= .9f
;
843 if (on_left(r
->i_cm
.map
[ic
]))
844 r
->map_table
[oc
][ic
] = .1f
/ (float) ic_unconnected_left
;
849 if (ic_unconnected_right
> 0) {
851 /* OK, so there are unconnected input channels on the
852 * right. Let's multiply all already connected channels on
853 * the right side by .9 and add in our averaged unconnected
854 * channels multplied by .1 */
856 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
858 if (!on_right(r
->o_cm
.map
[oc
]))
861 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
863 if (ic_connected
[ic
]) {
864 r
->map_table
[oc
][ic
] *= .9f
;
868 if (on_right(r
->i_cm
.map
[ic
]))
869 r
->map_table
[oc
][ic
] = .1f
/ (float) ic_unconnected_right
;
874 if (ic_unconnected_center
> 0) {
875 pa_bool_t mixed_in
= FALSE
;
877 /* OK, so there are unconnected input channels on the
878 * center. Let's multiply all already connected channels on
879 * the center side by .9 and add in our averaged unconnected
880 * channels multplied by .1 */
882 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
884 if (!on_center(r
->o_cm
.map
[oc
]))
887 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
889 if (ic_connected
[ic
]) {
890 r
->map_table
[oc
][ic
] *= .9f
;
894 if (on_center(r
->i_cm
.map
[ic
])) {
895 r
->map_table
[oc
][ic
] = .1f
/ (float) ic_unconnected_center
;
902 unsigned ncenter
[PA_CHANNELS_MAX
];
903 pa_bool_t found_frs
[PA_CHANNELS_MAX
];
905 memset(ncenter
, 0, sizeof(ncenter
));
906 memset(found_frs
, 0, sizeof(found_frs
));
908 /* Hmm, as it appears there was no center channel we
909 could mix our center channel in. In this case, mix
910 it into left and right. Using .375 and 0.75 as
913 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
915 if (ic_connected
[ic
])
918 if (!on_center(r
->i_cm
.map
[ic
]))
921 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
923 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
926 if (front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
])) {
927 found_frs
[ic
] = TRUE
;
932 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
934 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
937 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
942 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
944 if (!on_left(r
->o_cm
.map
[oc
]) && !on_right(r
->o_cm
.map
[oc
]))
947 if (ncenter
[oc
] <= 0)
950 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
952 if (ic_connected
[ic
]) {
953 r
->map_table
[oc
][ic
] *= .75f
;
957 if (!on_center(r
->i_cm
.map
[ic
]))
960 if (!found_frs
[ic
] || front_rear_side(r
->i_cm
.map
[ic
]) == front_rear_side(r
->o_cm
.map
[oc
]))
961 r
->map_table
[oc
][ic
] = .375f
/ (float) ncenter
[oc
];
967 if (ic_unconnected_lfe
> 0 && !(r
->flags
& PA_RESAMPLER_NO_LFE
)) {
969 /* OK, so there is an unconnected LFE channel. Let's mix
970 * it into all channels, with factor 0.375 */
972 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
974 if (!on_lfe(r
->i_cm
.map
[ic
]))
977 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++)
978 r
->map_table
[oc
][ic
] = 0.375f
/ (float) ic_unconnected_lfe
;
986 pa_strbuf_printf(s
, " ");
987 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
988 pa_strbuf_printf(s
, " I%02u ", ic
);
989 pa_strbuf_puts(s
, "\n +");
991 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
992 pa_strbuf_printf(s
, "------");
993 pa_strbuf_puts(s
, "\n");
995 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
996 pa_strbuf_printf(s
, "O%02u |", oc
);
998 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++)
999 pa_strbuf_printf(s
, " %1.3f", r
->map_table
[oc
][ic
]);
1001 pa_strbuf_puts(s
, "\n");
1004 pa_log_debug("Channel matrix:\n%s", t
= pa_strbuf_tostring_free(s
));
1008 static pa_memchunk
* convert_to_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1014 pa_assert(input
->memblock
);
1016 /* Convert the incoming sample into the work sample format and place them in buf1 */
1018 if (!r
->to_work_format_func
|| !input
->length
)
1021 n_samples
= (unsigned) ((input
->length
/ r
->i_fz
) * r
->i_ss
.channels
);
1024 r
->buf1
.length
= r
->w_sz
* n_samples
;
1026 if (!r
->buf1
.memblock
|| r
->buf1_samples
< n_samples
) {
1027 if (r
->buf1
.memblock
)
1028 pa_memblock_unref(r
->buf1
.memblock
);
1030 r
->buf1_samples
= n_samples
;
1031 r
->buf1
.memblock
= pa_memblock_new(r
->mempool
, r
->buf1
.length
);
1034 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1035 dst
= (uint8_t*) pa_memblock_acquire(r
->buf1
.memblock
);
1037 r
->to_work_format_func(n_samples
, src
, dst
);
1039 pa_memblock_release(input
->memblock
);
1040 pa_memblock_release(r
->buf1
.memblock
);
1045 static void vectoradd_f32(
1047 const float *s
, int sstr
,
1050 for (; n
> 0; n
--) {
1051 *d
= (float) (*d
+ (s4
* *s
));
1053 s
= (const float*) ((const uint8_t*) s
+ sstr
);
1054 d
= (float*) ((uint8_t*) d
+ dstr
);
1058 static void vectoradd_s16(
1059 int16_t *d
, int dstr
,
1060 const int16_t *s
, int sstr
,
1063 for (; n
> 0; n
--) {
1064 *d
= (int16_t) (*d
+ *s
);
1066 s
= (const int16_t*) ((const uint8_t*) s
+ sstr
);
1067 d
= (int16_t*) ((uint8_t*) d
+ dstr
);
1071 static void vectoradd_s16_with_fraction(
1072 int16_t *d
, int dstr
,
1073 const int16_t *s
, int sstr
,
1078 i4
= (int32_t) (s4
* 0x10000);
1080 for (; n
> 0; n
--) {
1081 *d
= (int16_t) (*d
+ (((int32_t)*s
* i4
) >> 16));
1083 s
= (const int16_t*) ((const uint8_t*) s
+ sstr
);
1084 d
= (int16_t*) ((uint8_t*) d
+ dstr
);
1088 static pa_memchunk
*remap_channels(pa_resampler
*r
, pa_memchunk
*input
) {
1089 unsigned in_n_samples
, out_n_samples
, n_frames
;
1096 pa_assert(input
->memblock
);
1098 /* Remap channels and place the result int buf2 */
1100 if (!r
->map_required
|| !input
->length
)
1103 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1104 n_frames
= in_n_samples
/ r
->i_ss
.channels
;
1105 out_n_samples
= n_frames
* r
->o_ss
.channels
;
1108 r
->buf2
.length
= r
->w_sz
* out_n_samples
;
1110 if (!r
->buf2
.memblock
|| r
->buf2_samples
< out_n_samples
) {
1111 if (r
->buf2
.memblock
)
1112 pa_memblock_unref(r
->buf2
.memblock
);
1114 r
->buf2_samples
= out_n_samples
;
1115 r
->buf2
.memblock
= pa_memblock_new(r
->mempool
, r
->buf2
.length
);
1118 src
= ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1119 dst
= pa_memblock_acquire(r
->buf2
.memblock
);
1121 memset(dst
, 0, r
->buf2
.length
);
1123 o_skip
= (int) (r
->w_sz
* r
->o_ss
.channels
);
1124 i_skip
= (int) (r
->w_sz
* r
->i_ss
.channels
);
1126 switch (r
->work_format
) {
1127 case PA_SAMPLE_FLOAT32NE
:
1129 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
1131 static const float one
= 1.0;
1133 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
1135 if (r
->map_table
[oc
][ic
] <= 0.0)
1139 (float*) dst
+ oc
, o_skip
,
1140 (float*) src
+ ic
, i_skip
,
1142 r
->map_table
[oc
][ic
]);
1148 case PA_SAMPLE_S16NE
:
1150 for (oc
= 0; oc
< r
->o_ss
.channels
; oc
++) {
1153 for (ic
= 0; ic
< r
->i_ss
.channels
; ic
++) {
1155 if (r
->map_table
[oc
][ic
] <= 0.0)
1158 if (r
->map_table
[oc
][ic
] >= 1.0) {
1161 (int16_t*) dst
+ oc
, o_skip
,
1162 (int16_t*) src
+ ic
, i_skip
,
1167 vectoradd_s16_with_fraction(
1168 (int16_t*) dst
+ oc
, o_skip
,
1169 (int16_t*) src
+ ic
, i_skip
,
1171 r
->map_table
[oc
][ic
]);
1178 pa_assert_not_reached();
1181 pa_memblock_release(input
->memblock
);
1182 pa_memblock_release(r
->buf2
.memblock
);
1184 r
->buf2
.length
= out_n_samples
* r
->w_sz
;
1189 static pa_memchunk
*resample(pa_resampler
*r
, pa_memchunk
*input
) {
1190 unsigned in_n_frames
, in_n_samples
;
1191 unsigned out_n_frames
, out_n_samples
;
1196 /* Resample the data and place the result in buf3 */
1198 if (!r
->impl_resample
|| !input
->length
)
1201 in_n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1202 in_n_frames
= (unsigned) (in_n_samples
/ r
->o_ss
.channels
);
1204 out_n_frames
= ((in_n_frames
*r
->o_ss
.rate
)/r
->i_ss
.rate
)+EXTRA_FRAMES
;
1205 out_n_samples
= out_n_frames
* r
->o_ss
.channels
;
1208 r
->buf3
.length
= r
->w_sz
* out_n_samples
;
1210 if (!r
->buf3
.memblock
|| r
->buf3_samples
< out_n_samples
) {
1211 if (r
->buf3
.memblock
)
1212 pa_memblock_unref(r
->buf3
.memblock
);
1214 r
->buf3_samples
= out_n_samples
;
1215 r
->buf3
.memblock
= pa_memblock_new(r
->mempool
, r
->buf3
.length
);
1218 r
->impl_resample(r
, input
, in_n_frames
, &r
->buf3
, &out_n_frames
);
1219 r
->buf3
.length
= out_n_frames
* r
->w_sz
* r
->o_ss
.channels
;
1224 static pa_memchunk
*convert_from_work_format(pa_resampler
*r
, pa_memchunk
*input
) {
1225 unsigned n_samples
, n_frames
;
1231 /* Convert the data into the correct sample type and place the result in buf4 */
1233 if (!r
->from_work_format_func
|| !input
->length
)
1236 n_samples
= (unsigned) (input
->length
/ r
->w_sz
);
1237 n_frames
= n_samples
/ r
->o_ss
.channels
;
1240 r
->buf4
.length
= r
->o_fz
* n_frames
;
1242 if (!r
->buf4
.memblock
|| r
->buf4_samples
< n_samples
) {
1243 if (r
->buf4
.memblock
)
1244 pa_memblock_unref(r
->buf4
.memblock
);
1246 r
->buf4_samples
= n_samples
;
1247 r
->buf4
.memblock
= pa_memblock_new(r
->mempool
, r
->buf4
.length
);
1250 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1251 dst
= pa_memblock_acquire(r
->buf4
.memblock
);
1252 r
->from_work_format_func(n_samples
, src
, dst
);
1253 pa_memblock_release(input
->memblock
);
1254 pa_memblock_release(r
->buf4
.memblock
);
1256 r
->buf4
.length
= r
->o_fz
* n_frames
;
1261 void pa_resampler_run(pa_resampler
*r
, const pa_memchunk
*in
, pa_memchunk
*out
) {
1267 pa_assert(in
->length
);
1268 pa_assert(in
->memblock
);
1269 pa_assert(in
->length
% r
->i_fz
== 0);
1271 buf
= (pa_memchunk
*) in
;
1272 buf
= convert_to_work_format(r
, buf
);
1273 buf
= remap_channels(r
, buf
);
1274 buf
= resample(r
, buf
);
1277 buf
= convert_from_work_format(r
, buf
);
1281 pa_memblock_ref(buf
->memblock
);
1283 pa_memchunk_reset(buf
);
1285 pa_memchunk_reset(out
);
1288 /*** libsamplerate based implementation ***/
1290 #ifdef HAVE_LIBSAMPLERATE
1291 static void libsamplerate_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1297 pa_assert(out_n_frames
);
1299 memset(&data
, 0, sizeof(data
));
1301 data
.data_in
= (float*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1302 data
.input_frames
= (long int) in_n_frames
;
1304 data
.data_out
= (float*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
);
1305 data
.output_frames
= (long int) *out_n_frames
;
1307 data
.src_ratio
= (double) r
->o_ss
.rate
/ r
->i_ss
.rate
;
1308 data
.end_of_input
= 0;
1310 pa_assert_se(src_process(r
->src
.state
, &data
) == 0);
1311 pa_assert((unsigned) data
.input_frames_used
== in_n_frames
);
1313 pa_memblock_release(input
->memblock
);
1314 pa_memblock_release(output
->memblock
);
1316 *out_n_frames
= (unsigned) data
.output_frames_gen
;
1319 static void libsamplerate_update_rates(pa_resampler
*r
) {
1322 pa_assert_se(src_set_ratio(r
->src
.state
, (double) r
->o_ss
.rate
/ r
->i_ss
.rate
) == 0);
1325 static void libsamplerate_reset(pa_resampler
*r
) {
1328 pa_assert_se(src_reset(r
->src
.state
) == 0);
1331 static void libsamplerate_free(pa_resampler
*r
) {
1335 src_delete(r
->src
.state
);
1338 static int libsamplerate_init(pa_resampler
*r
) {
1343 if (!(r
->src
.state
= src_new(r
->method
, r
->o_ss
.channels
, &err
)))
1346 r
->impl_free
= libsamplerate_free
;
1347 r
->impl_update_rates
= libsamplerate_update_rates
;
1348 r
->impl_resample
= libsamplerate_resample
;
1349 r
->impl_reset
= libsamplerate_reset
;
1355 /*** speex based implementation ***/
1357 static void speex_resample_float(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1359 uint32_t inf
= in_n_frames
, outf
= *out_n_frames
;
1364 pa_assert(out_n_frames
);
1366 in
= (float*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1367 out
= (float*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
);
1369 pa_assert_se(speex_resampler_process_interleaved_float(r
->speex
.state
, in
, &inf
, out
, &outf
) == 0);
1371 pa_memblock_release(input
->memblock
);
1372 pa_memblock_release(output
->memblock
);
1374 pa_assert(inf
== in_n_frames
);
1375 *out_n_frames
= outf
;
1378 static void speex_resample_int(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1380 uint32_t inf
= in_n_frames
, outf
= *out_n_frames
;
1385 pa_assert(out_n_frames
);
1387 in
= (int16_t*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
);
1388 out
= (int16_t*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
);
1390 pa_assert_se(speex_resampler_process_interleaved_int(r
->speex
.state
, in
, &inf
, out
, &outf
) == 0);
1392 pa_memblock_release(input
->memblock
);
1393 pa_memblock_release(output
->memblock
);
1395 pa_assert(inf
== in_n_frames
);
1396 *out_n_frames
= outf
;
1399 static void speex_update_rates(pa_resampler
*r
) {
1402 pa_assert_se(speex_resampler_set_rate(r
->speex
.state
, r
->i_ss
.rate
, r
->o_ss
.rate
) == 0);
1405 static void speex_reset(pa_resampler
*r
) {
1408 pa_assert_se(speex_resampler_reset_mem(r
->speex
.state
) == 0);
1411 static void speex_free(pa_resampler
*r
) {
1414 if (!r
->speex
.state
)
1417 speex_resampler_destroy(r
->speex
.state
);
1420 static int speex_init(pa_resampler
*r
) {
1425 r
->impl_free
= speex_free
;
1426 r
->impl_update_rates
= speex_update_rates
;
1427 r
->impl_reset
= speex_reset
;
1429 if (r
->method
>= PA_RESAMPLER_SPEEX_FIXED_BASE
&& r
->method
<= PA_RESAMPLER_SPEEX_FIXED_MAX
) {
1431 q
= r
->method
- PA_RESAMPLER_SPEEX_FIXED_BASE
;
1432 r
->impl_resample
= speex_resample_int
;
1435 pa_assert(r
->method
>= PA_RESAMPLER_SPEEX_FLOAT_BASE
&& r
->method
<= PA_RESAMPLER_SPEEX_FLOAT_MAX
);
1437 q
= r
->method
- PA_RESAMPLER_SPEEX_FLOAT_BASE
;
1438 r
->impl_resample
= speex_resample_float
;
1441 pa_log_info("Choosing speex quality setting %i.", q
);
1443 if (!(r
->speex
.state
= speex_resampler_init(r
->o_ss
.channels
, r
->i_ss
.rate
, r
->o_ss
.rate
, q
, &err
)))
1449 /* Trivial implementation */
1451 static void trivial_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1459 pa_assert(out_n_frames
);
1461 fz
= r
->w_sz
* r
->o_ss
.channels
;
1463 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1464 dst
= (uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
;
1466 for (o_index
= 0;; o_index
++, r
->trivial
.o_counter
++) {
1469 j
= ((r
->trivial
.o_counter
* r
->i_ss
.rate
) / r
->o_ss
.rate
);
1470 j
= j
> r
->trivial
.i_counter
? j
- r
->trivial
.i_counter
: 0;
1472 if (j
>= in_n_frames
)
1475 pa_assert(o_index
* fz
< pa_memblock_get_length(output
->memblock
));
1477 memcpy((uint8_t*) dst
+ fz
* o_index
,
1478 (uint8_t*) src
+ fz
* j
, (int) fz
);
1481 pa_memblock_release(input
->memblock
);
1482 pa_memblock_release(output
->memblock
);
1484 *out_n_frames
= o_index
;
1486 r
->trivial
.i_counter
+= in_n_frames
;
1488 /* Normalize counters */
1489 while (r
->trivial
.i_counter
>= r
->i_ss
.rate
) {
1490 pa_assert(r
->trivial
.o_counter
>= r
->o_ss
.rate
);
1492 r
->trivial
.i_counter
-= r
->i_ss
.rate
;
1493 r
->trivial
.o_counter
-= r
->o_ss
.rate
;
1497 static void trivial_update_rates_or_reset(pa_resampler
*r
) {
1500 r
->trivial
.i_counter
= 0;
1501 r
->trivial
.o_counter
= 0;
1504 static int trivial_init(pa_resampler
*r
) {
1507 r
->trivial
.o_counter
= r
->trivial
.i_counter
= 0;
1509 r
->impl_resample
= trivial_resample
;
1510 r
->impl_update_rates
= trivial_update_rates_or_reset
;
1511 r
->impl_reset
= trivial_update_rates_or_reset
;
1516 /* Peak finder implementation */
1518 static void peaks_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1527 pa_assert(out_n_frames
);
1529 fz
= r
->w_sz
* r
->o_ss
.channels
;
1531 src
= (uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
;
1532 dst
= (uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
;
1534 for (o_index
= 0;; o_index
++, r
->peaks
.o_counter
++) {
1537 j
= ((r
->peaks
.o_counter
* r
->i_ss
.rate
) / r
->o_ss
.rate
);
1539 if (j
> r
->peaks
.i_counter
)
1540 j
-= r
->peaks
.i_counter
;
1544 pa_assert(o_index
* fz
< pa_memblock_get_length(output
->memblock
));
1546 if (r
->work_format
== PA_SAMPLE_S16NE
) {
1548 int16_t *s
= (int16_t*) ((uint8_t*) src
+ fz
* start
);
1549 int16_t *d
= (int16_t*) ((uint8_t*) dst
+ fz
* o_index
);
1551 for (i
= start
; i
<= j
&& i
< in_n_frames
; i
++)
1553 for (c
= 0; c
< r
->o_ss
.channels
; c
++, s
++) {
1556 n
= (int16_t) (*s
< 0 ? -*s
: *s
);
1558 if (PA_UNLIKELY(n
> r
->peaks
.max_i
[c
]))
1559 r
->peaks
.max_i
[c
] = n
;
1562 if (i
>= in_n_frames
)
1565 for (c
= 0; c
< r
->o_ss
.channels
; c
++, d
++) {
1566 *d
= r
->peaks
.max_i
[c
];
1567 r
->peaks
.max_i
[c
] = 0;
1572 float *s
= (float*) ((uint8_t*) src
+ fz
* start
);
1573 float *d
= (float*) ((uint8_t*) dst
+ fz
* o_index
);
1575 pa_assert(r
->work_format
== PA_SAMPLE_FLOAT32NE
);
1577 for (i
= start
; i
<= j
&& i
< in_n_frames
; i
++)
1578 for (c
= 0; c
< r
->o_ss
.channels
; c
++, s
++) {
1579 float n
= fabsf(*s
);
1581 if (n
> r
->peaks
.max_f
[c
])
1582 r
->peaks
.max_f
[c
] = n
;
1585 if (i
>= in_n_frames
)
1588 for (c
= 0; c
< r
->o_ss
.channels
; c
++, d
++) {
1589 *d
= r
->peaks
.max_f
[c
];
1590 r
->peaks
.max_f
[c
] = 0;
1597 pa_memblock_release(input
->memblock
);
1598 pa_memblock_release(output
->memblock
);
1600 *out_n_frames
= o_index
;
1602 r
->peaks
.i_counter
+= in_n_frames
;
1604 /* Normalize counters */
1605 while (r
->peaks
.i_counter
>= r
->i_ss
.rate
) {
1606 pa_assert(r
->peaks
.o_counter
>= r
->o_ss
.rate
);
1608 r
->peaks
.i_counter
-= r
->i_ss
.rate
;
1609 r
->peaks
.o_counter
-= r
->o_ss
.rate
;
1613 static void peaks_update_rates_or_reset(pa_resampler
*r
) {
1616 r
->peaks
.i_counter
= 0;
1617 r
->peaks
.o_counter
= 0;
1620 static int peaks_init(pa_resampler
*r
) {
1623 r
->peaks
.o_counter
= r
->peaks
.i_counter
= 0;
1624 memset(r
->peaks
.max_i
, 0, sizeof(r
->peaks
.max_i
));
1625 memset(r
->peaks
.max_f
, 0, sizeof(r
->peaks
.max_f
));
1627 r
->impl_resample
= peaks_resample
;
1628 r
->impl_update_rates
= peaks_update_rates_or_reset
;
1629 r
->impl_reset
= peaks_update_rates_or_reset
;
1634 /*** ffmpeg based implementation ***/
1636 static void ffmpeg_resample(pa_resampler
*r
, const pa_memchunk
*input
, unsigned in_n_frames
, pa_memchunk
*output
, unsigned *out_n_frames
) {
1637 unsigned used_frames
= 0, c
;
1642 pa_assert(out_n_frames
);
1644 for (c
= 0; c
< r
->o_ss
.channels
; c
++) {
1647 int16_t *p
, *t
, *k
, *q
, *s
;
1648 int consumed_frames
;
1651 /* Allocate a new block */
1652 b
= pa_memblock_new(r
->mempool
, r
->ffmpeg
.buf
[c
].length
+ in_n_frames
* sizeof(int16_t));
1653 p
= pa_memblock_acquire(b
);
1655 /* Copy the remaining data into it */
1656 l
= (unsigned) r
->ffmpeg
.buf
[c
].length
;
1657 if (r
->ffmpeg
.buf
[c
].memblock
) {
1658 t
= (int16_t*) ((uint8_t*) pa_memblock_acquire(r
->ffmpeg
.buf
[c
].memblock
) + r
->ffmpeg
.buf
[c
].index
);
1660 pa_memblock_release(r
->ffmpeg
.buf
[c
].memblock
);
1661 pa_memblock_unref(r
->ffmpeg
.buf
[c
].memblock
);
1662 pa_memchunk_reset(&r
->ffmpeg
.buf
[c
]);
1665 /* Now append the new data, splitting up channels */
1666 t
= ((int16_t*) ((uint8_t*) pa_memblock_acquire(input
->memblock
) + input
->index
)) + c
;
1667 k
= (int16_t*) ((uint8_t*) p
+ l
);
1668 for (u
= 0; u
< in_n_frames
; u
++) {
1670 t
+= r
->o_ss
.channels
;
1673 pa_memblock_release(input
->memblock
);
1675 /* Calculate the resulting number of frames */
1676 in
= (unsigned) in_n_frames
+ l
/ (unsigned) sizeof(int16_t);
1678 /* Allocate buffer for the result */
1679 w
= pa_memblock_new(r
->mempool
, *out_n_frames
* sizeof(int16_t));
1680 q
= pa_memblock_acquire(w
);
1683 used_frames
= (unsigned) av_resample(r
->ffmpeg
.state
,
1686 (int) in
, (int) *out_n_frames
,
1687 c
>= (unsigned) (r
->o_ss
.channels
-1));
1689 pa_memblock_release(b
);
1691 /* Now store the remaining samples away */
1692 pa_assert(consumed_frames
<= (int) in
);
1693 if (consumed_frames
< (int) in
) {
1694 r
->ffmpeg
.buf
[c
].memblock
= b
;
1695 r
->ffmpeg
.buf
[c
].index
= (size_t) consumed_frames
* sizeof(int16_t);
1696 r
->ffmpeg
.buf
[c
].length
= (size_t) (in
- (unsigned) consumed_frames
) * sizeof(int16_t);
1698 pa_memblock_unref(b
);
1700 /* And place the results in the output buffer */
1701 s
= (short*) ((uint8_t*) pa_memblock_acquire(output
->memblock
) + output
->index
) + c
;
1702 for (u
= 0; u
< used_frames
; u
++) {
1705 s
+= r
->o_ss
.channels
;
1707 pa_memblock_release(output
->memblock
);
1708 pa_memblock_release(w
);
1709 pa_memblock_unref(w
);
1712 *out_n_frames
= used_frames
;
1715 static void ffmpeg_free(pa_resampler
*r
) {
1720 if (r
->ffmpeg
.state
)
1721 av_resample_close(r
->ffmpeg
.state
);
1723 for (c
= 0; c
< PA_ELEMENTSOF(r
->ffmpeg
.buf
); c
++)
1724 if (r
->ffmpeg
.buf
[c
].memblock
)
1725 pa_memblock_unref(r
->ffmpeg
.buf
[c
].memblock
);
1728 static int ffmpeg_init(pa_resampler
*r
) {
1733 /* We could probably implement different quality levels by
1734 * adjusting the filter parameters here. However, ffmpeg
1735 * internally only uses these hardcoded values, so let's use them
1736 * here for now as well until ffmpeg makes this configurable. */
1738 if (!(r
->ffmpeg
.state
= av_resample_init((int) r
->o_ss
.rate
, (int) r
->i_ss
.rate
, 16, 10, 0, 0.8)))
1741 r
->impl_free
= ffmpeg_free
;
1742 r
->impl_resample
= ffmpeg_resample
;
1744 for (c
= 0; c
< PA_ELEMENTSOF(r
->ffmpeg
.buf
); c
++)
1745 pa_memchunk_reset(&r
->ffmpeg
.buf
[c
]);
1750 /*** copy (noop) implementation ***/
1752 static int copy_init(pa_resampler
*r
) {
1755 pa_assert(r
->o_ss
.rate
== r
->i_ss
.rate
);