chiark / gitweb /
examples/disorder.init.in: Read settings from `/etc/default/disorder'.
[disorder] / lib / resample.c
1 /*
2  * This file is part of DisOrder.
3  * Copyright (C) 2009 Richard Kettlewell
4  *
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.
9  *
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.
14  * 
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/>.
17  */
18
19 /** @file lib/resample.c
20  * @brief Audio resampling
21  *
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.
25  */
26
27 #include "common.h"
28 #include "resample.h"
29 #include "log.h"
30 #include "mem.h"
31
32 /** @brief Number of intermediate-format samples */
33 #define SAMPLES 1024
34
35 /** @brief Multiplier for signed formats to allow easy switching */
36 #define SIGNED 4
37
38 /** @brief Initialize a resampler
39  * @param rs 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)
50  *
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.
55  */
56 void resample_init(struct resampler *rs,
57                     int input_bits, int input_channels,
58                     int input_rate, int input_signed,
59                     int input_endian,
60                     int output_bits, int output_channels,
61                     int output_rate, int output_signed,
62                     int output_endian) {
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) {
83 #if HAVE_SAMPLERATE_H
84     int error_;
85     rs->state = src_new(SRC_SINC_BEST_QUALITY, rs->output_channels, &error_);
86     if(!rs->state)
87       disorder_fatal(0, "calling src_new: %s", src_strerror(error_));
88 #else
89     disorder_fatal(0, "need to resample audio data but libsamplerate not available");
90 #endif
91   }
92 }
93
94 /** @brief Destroy a resampler
95  * @param rs Resampler
96  */
97 void resample_close(struct resampler *rs) {
98 #if HAVE_SAMPLERATE_H
99   if(rs->state)
100     src_delete(rs->state);
101 #else
102   if(rs){}                              /* quieten compiler */
103 #endif
104 }
105
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
111  */
112 static size_t resample_get_sample(const struct resampler *rs,
113                                   const uint8_t *bytes,
114                                   float *where) {
115   switch(rs->input_bits + rs->input_signed + rs->input_endian) {
116   case 8+ENDIAN_BIG:
117   case 8+ENDIAN_LITTLE:
118     *where = (bytes[0] - 128)/ 128.0;
119     return 1;
120   case 8+SIGNED+ENDIAN_BIG:
121   case 8+SIGNED+ENDIAN_LITTLE:
122     *where = (int8_t)bytes[0] / 128.0;
123     return 1;
124   case 16+ENDIAN_BIG:
125     *where = (bytes[0] * 256 + bytes[1] - 32768)/ 32768.0;
126     return 2;
127     break;
128   case 16+ENDIAN_LITTLE:
129     *where = (bytes[1] * 256 + bytes[0] - 32768)/ 32768.0;
130     return 2;
131     break;
132   case 16+SIGNED+ENDIAN_BIG:
133     *where = (int16_t)(bytes[0] * 256 + bytes[1])/ 32768.0;
134     return 2;
135     break;
136   case 16+SIGNED+ENDIAN_LITTLE:
137     *where = (int16_t)(bytes[1] * 256 + bytes[0])/ 32768.0;
138     return 2;
139     break;
140   default:
141     assert(!"unsupported sample format");
142   }
143 }
144
145 static inline int clip(int n, int min, int max) {
146   if(n >= min) {
147     if(n <= max)
148       return n;
149     else
150       return max;
151   } else
152     return min;
153 }
154
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
160  *
161  * The value is clipped naively if it will not fit.
162  */
163 static size_t resample_put_sample(const struct resampler *rs,
164                                   float sample,
165                                   uint8_t *bytes) {
166   unsigned value;
167   switch(rs->output_bits + rs->output_signed + rs->output_endian) {
168   case 8+ENDIAN_BIG:
169   case 8+ENDIAN_LITTLE:
170     *bytes = clip(sample * 128.0 + 128, 0, 255);
171     return 1;
172   case 8+SIGNED+ENDIAN_BIG:
173   case 8+SIGNED+ENDIAN_LITTLE:
174     *bytes = clip((int)(sample * 128.0), -128, 127);
175     return 1;
176   case 16+ENDIAN_BIG:                   /* unsigned */
177     value = clip(sample * 32768.0 + 32768, 0, 65535);
178     *bytes++ = value >> 8;
179     *bytes++ = value;
180     return 2;
181   case 16+ENDIAN_LITTLE:
182     value = clip(sample * 32768.0 + 32768, 0, 65535);
183     *bytes++ = value;
184     *bytes++ = value >> 8;
185     return 2;
186   case 16+SIGNED+ENDIAN_BIG:
187     value = clip(sample * 32768.0, -32768, 32767);
188     *bytes++ = value >> 8;
189     *bytes++ = value;
190     return 2;
191   case 16+SIGNED+ENDIAN_LITTLE:
192     value = clip(sample * 32768.0, -32768, 32767);
193     *bytes++ = value;
194     *bytes++ = value >> 8;
195     return 2;
196   default:
197     assert(!"unsupported sample format");
198   }
199 }
200
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
206  *
207  * @p floats must be big enough.  As well as converting to floats this
208  * also converts to the output's channel format.
209  *
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
215  * too bad.
216  */
217 static void resample_prepare_input(const struct resampler *rs,
218                                    const uint8_t *bytes,
219                                    size_t nframes,
220                                    float *floats) {
221   while(nframes > 0) {
222     int n;
223
224     for(n = 0; n < rs->input_channels && n < rs->output_channels; ++n) {
225       bytes += resample_get_sample(rs, bytes, floats);
226       ++floats;
227     }
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];
235         ++floats;
236       }
237     }
238     --nframes;
239   }
240 }
241
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
250  */
251 size_t resample_convert(const struct resampler *rs,
252                         const uint8_t *bytes,
253                         size_t nbytes,
254                         int eof,
255                         void (*converted)(uint8_t *bytes,
256                                           size_t nbytes,
257                                           void *cd),
258                         void *cd) {
259   size_t nframesin = nbytes / (rs->input_bytes_per_frame);
260   size_t nsamplesout;
261   float *input = xcalloc(nframesin * rs->output_channels, sizeof (float));
262   float *output = 0;
263
264   resample_prepare_input(rs, bytes, nframesin, input);
265 #if HAVE_SAMPLERATE_H
266   if(rs->state) {
267     /* A sample-rate conversion must be performed */
268     SRC_DATA data;
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,
281        (int)data.src_ratio,
282        ((int)(data.src_ratio * 1000000) % 1000000)));
283     int error_ = src_process(rs->state, &data);
284     if(error_)
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));
289   }
290 #endif
291   if(!output) {
292     /* No sample-rate conversion required */
293     output = input;
294     nsamplesout = nframesin * rs->output_channels;
295   }
296   const float *op = output;
297   while(nsamplesout > 0) {
298     uint8_t buffer[4096];
299     size_t bufused = 0;
300
301     while(bufused < sizeof buffer && nsamplesout > 0) {
302       bufused += resample_put_sample(rs, *op++, buffer + bufused);
303       --nsamplesout;
304     }
305     converted(buffer, bufused, cd);
306   }
307   if(output != input)
308     xfree(output);
309   xfree(input);
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;
314 }
315
316 /*
317 Local Variables:
318 c-basic-offset:2
319 comment-column:40
320 fill-column:79
321 indent-tabs-mode:nil
322 End:
323 */