2 * This file is part of DisOrder.
3 * Copyright (C) 2009 Richard Kettlewell
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 /** @file lib/resample.c
20 * @brief Audio resampling
22 * General purpose audio format conversion. Rate conversion only works if the
23 * SRC samplerate library is available, but the bitness/channel/endianness
24 * conversion works regardless.
32 /** @brief Number of intermediate-format samples */
35 /** @brief Multiplier for signed formats to allow easy switching */
38 /** @brief Initialize a resampler
40 * @param input_bits Bits/sample in input
41 * @param input_channels Number of input channels
42 * @param input_signed Whether input samples are signed or unsigned
43 * @param input_rate Frames/second in input
44 * @param input_endian Input endianness (@c ENDIAN_BIG or @c ENDIAN_LITTLE)
45 * @param output_bits Bits/sample in output
46 * @param output_channels Number of output channels
47 * @param output_rate Frames/second in output
48 * @param output_signed Whether output samples are signed or unsigned
49 * @param output_endian Output endianness (@c ENDIAN_BIG or @c ENDIAN_LITTLE)
51 * For formats with more than two channels it's assume that the first
52 * two channels are left and right. No particular meaning is attached
53 * to additional channels other than to assume channel N in an input
54 * means the same as channel N in an output, for N>1.
56 void resample_init(struct resampler
*rs
,
57 int input_bits
, int input_channels
,
58 int input_rate
, int input_signed
,
60 int output_bits
, int output_channels
,
61 int output_rate
, int output_signed
,
63 memset(rs
, 0, sizeof *rs
);
64 assert(input_bits
== 8 || input_bits
== 16);
65 assert(output_bits
== 8 || output_bits
== 16);
66 assert(input_endian
== ENDIAN_BIG
|| input_endian
== ENDIAN_LITTLE
);
67 assert(output_endian
== ENDIAN_BIG
|| output_endian
== ENDIAN_LITTLE
);
68 assert(ENDIAN_BIG
>= 0 && ENDIAN_BIG
< SIGNED
);
69 assert(ENDIAN_LITTLE
>= 0 && ENDIAN_LITTLE
< SIGNED
);
70 rs
->input_bits
= input_bits
;
71 rs
->input_channels
= input_channels
;
72 rs
->input_rate
= input_rate
;
73 rs
->input_signed
= SIGNED
* !!input_signed
;
74 rs
->input_endian
= input_endian
;
75 rs
->output_bits
= output_bits
;
76 rs
->output_channels
= output_channels
;
77 rs
->output_rate
= output_rate
;
78 rs
->output_signed
= SIGNED
* !!output_signed
;
79 rs
->output_endian
= output_endian
;
80 rs
->input_bytes_per_sample
= (rs
->input_bits
+ 7) / 8;
81 rs
->input_bytes_per_frame
= rs
->input_channels
* rs
->input_bytes_per_sample
;
82 if(rs
->input_rate
!= rs
->output_rate
) {
85 rs
->state
= src_new(SRC_SINC_BEST_QUALITY
, rs
->output_channels
, &error_
);
87 disorder_fatal(0, "calling src_new: %s", src_strerror(error_
));
89 disorder_fatal(0, "need to resample audio data but libsamplerate not available");
94 /** @brief Destroy a resampler
97 void resample_close(struct resampler
*rs
) {
100 src_delete(rs
->state
);
102 if(rs
){} /* quieten compiler */
106 /** @brief Get one sample value and normalize it to [-1,1]
107 * @param rs Resampler state
108 * @param bytes Pointer to input data
109 * @param where Where to store result
110 * @return Number of bytes consumed
112 static size_t resample_get_sample(const struct resampler
*rs
,
113 const uint8_t *bytes
,
115 switch(rs
->input_bits
+ rs
->input_signed
+ rs
->input_endian
) {
117 case 8+ENDIAN_LITTLE
:
118 *where
= (bytes
[0] - 128)/ 128.0;
120 case 8+SIGNED
+ENDIAN_BIG
:
121 case 8+SIGNED
+ENDIAN_LITTLE
:
122 *where
= (int8_t)bytes
[0] / 128.0;
125 *where
= (bytes
[0] * 256 + bytes
[1] - 32768)/ 32768.0;
128 case 16+ENDIAN_LITTLE
:
129 *where
= (bytes
[1] * 256 + bytes
[0] - 32768)/ 32768.0;
132 case 16+SIGNED
+ENDIAN_BIG
:
133 *where
= (int16_t)(bytes
[0] * 256 + bytes
[1])/ 32768.0;
136 case 16+SIGNED
+ENDIAN_LITTLE
:
137 *where
= (int16_t)(bytes
[1] * 256 + bytes
[0])/ 32768.0;
141 assert(!"unsupported sample format");
145 static inline int clip(int n
, int min
, int max
) {
155 /** @brief Store one sample value
156 * @param rs Resampler state
157 * @param sample Sample value
158 * @param bytes Where to store it
159 * @return Number of bytes stored
161 * The value is clipped naively if it will not fit.
163 static size_t resample_put_sample(const struct resampler
*rs
,
167 switch(rs
->output_bits
+ rs
->output_signed
+ rs
->output_endian
) {
169 case 8+ENDIAN_LITTLE
:
170 *bytes
= clip(sample
* 128.0 + 128, 0, 255);
172 case 8+SIGNED
+ENDIAN_BIG
:
173 case 8+SIGNED
+ENDIAN_LITTLE
:
174 *bytes
= clip((int)(sample
* 128.0), -128, 127);
176 case 16+ENDIAN_BIG
: /* unsigned */
177 value
= clip(sample
* 32768.0 + 32768, 0, 65535);
178 *bytes
++ = value
>> 8;
181 case 16+ENDIAN_LITTLE
:
182 value
= clip(sample
* 32768.0 + 32768, 0, 65535);
184 *bytes
++ = value
>> 8;
186 case 16+SIGNED
+ENDIAN_BIG
:
187 value
= clip(sample
* 32768.0, -32768, 32767);
188 *bytes
++ = value
>> 8;
191 case 16+SIGNED
+ENDIAN_LITTLE
:
192 value
= clip(sample
* 32768.0, -32768, 32767);
194 *bytes
++ = value
>> 8;
197 assert(!"unsupported sample format");
201 /** @brief Convert input samples to floats
202 * @param rs Resampler state
203 * @param bytes Input bytes
204 * @param nframes Number of input frames
205 * @param floats Where to store converted data
207 * @p floats must be big enough. As well as converting to floats this
208 * also converts to the output's channel format.
210 * Excess input channels are just discarded. If there are insufficient input
211 * channels the last one is duplicated as often as necessary to make up the
212 * numbers. This is a rather naff heuristic and may be improved in a future
213 * version, but mostly in DisOrder the output is pretty much always stereo and
214 * the input either mono or stereo, so the result isn't actually going to be
217 static void resample_prepare_input(const struct resampler
*rs
,
218 const uint8_t *bytes
,
224 for(n
= 0; n
< rs
->input_channels
&& n
< rs
->output_channels
; ++n
) {
225 bytes
+= resample_get_sample(rs
, bytes
, floats
);
228 if(n
< rs
->input_channels
) {
229 /* More input channels; discard them */
230 bytes
+= (rs
->input_channels
- n
) * rs
->input_bytes_per_sample
;
231 } else if(n
< rs
->output_channels
) {
232 /* More output channels; duplicate the last input channel */
233 for(; n
< rs
->output_channels
; ++n
) {
234 *floats
= floats
[-1];
242 /** @brief Convert between sample formats
243 * @param rs Resampler state
244 * @param bytes Bytes to convert
245 * @param nbytes Number of bytes to convert
246 * @param eof Set an end of input stream
247 * @param converted Called with converted data (possibly more than once)
248 * @param cd Passed to @p cd
249 * @return Number of bytes consumed
251 size_t resample_convert(const struct resampler
*rs
,
252 const uint8_t *bytes
,
255 void (*converted
)(uint8_t *bytes
,
259 size_t nframesin
= nbytes
/ (rs
->input_bytes_per_frame
);
261 float *input
= xcalloc(nframesin
* rs
->output_channels
, sizeof (float));
264 resample_prepare_input(rs
, bytes
, nframesin
, input
);
265 #if HAVE_SAMPLERATE_H
267 /* A sample-rate conversion must be performed */
269 memset(&data
, 0, sizeof data
);
270 /* Compute how many frames are expected to come out. */
271 size_t maxframesout
= nframesin
* rs
->output_rate
/ rs
->input_rate
+ 1;
272 output
= xcalloc(maxframesout
* rs
->output_channels
, sizeof(float));
273 data
.data_in
= input
;
274 data
.data_out
= output
;
275 data
.input_frames
= nframesin
;
276 data
.output_frames
= maxframesout
;
277 data
.end_of_input
= eof
;
278 data
.src_ratio
= (double)rs
->output_rate
/ rs
->input_rate
;
279 D(("nframesin=%zu maxframesout=%zu eof=%d ratio=%d.%06d",
280 nframesin
, maxframesout
, eof
,
282 ((int)(data
.src_ratio
* 1000000) % 1000000)));
283 int error_
= src_process(rs
->state
, &data
);
285 disorder_fatal(0, "calling src_process: %s", src_strerror(error_
));
286 nframesin
= data
.input_frames_used
;
287 nsamplesout
= data
.output_frames_gen
* rs
->output_channels
;
288 D(("new nframesin=%zu nsamplesout=%zu", nframesin
, nsamplesout
));
292 /* No sample-rate conversion required */
294 nsamplesout
= nframesin
* rs
->output_channels
;
296 const float *op
= output
;
297 while(nsamplesout
> 0) {
298 uint8_t buffer
[4096];
301 while(bufused
< sizeof buffer
&& nsamplesout
> 0) {
302 bufused
+= resample_put_sample(rs
, *op
++, buffer
+ bufused
);
305 converted(buffer
, bufused
, cd
);
310 if(eof
){} /* quieten compiler */
311 /* Report how many input bytes were actually consumed */
312 //fprintf(stderr, "converted %zu frames\n", nframesin);
313 return nframesin
* rs
->input_bytes_per_frame
;