Merge branch 't/image-0.5'
[paraslash.git] / resample_filter.c
1 /*
2 * Copyright (C) 2012-2013 Andre Noll <maan@systemlinux.org>
3 *
4 * Licensed under the GPL v2. For licencing details see COPYING.
5 */
6
7 /** \file resample_filter.c A sample rate converter based on libsamplerate. */
8
9 #include <regex.h>
10 #include <samplerate.h>
11
12 #include "resample_filter.cmdline.h"
13 #include "para.h"
14 #include "error.h"
15 #include "list.h"
16 #include "sched.h"
17 #include "ggo.h"
18 #include "buffer_tree.h"
19 #include "filter.h"
20 #include "string.h"
21 #include "check_wav.h"
22
23 struct resample_context {
24 int channels;
25 int source_sample_rate;
26 float ratio;
27 SRC_STATE *src_state;
28 struct check_wav_context *cwc;
29 };
30
31 static int resample_execute(struct btr_node *btrn, const char *cmd, char **result)
32 {
33 struct filter_node *fn = btr_context(btrn);
34 struct resample_context *ctx = fn->private_data;
35 struct resample_filter_args_info *conf = fn->conf;
36
37 return decoder_execute(cmd, conf->dest_sample_rate_arg, ctx->channels,
38 result);
39 }
40
41 static void resample_close(struct filter_node *fn)
42 {
43 struct resample_context *ctx = fn->private_data;
44
45 if (!ctx)
46 return;
47 check_wav_shutdown(ctx->cwc);
48 if (ctx->src_state)
49 src_delete(ctx->src_state);
50 free(ctx);
51 fn->private_data = NULL;
52 }
53
54 static void resample_open(struct filter_node *fn)
55 {
56 struct resample_context *ctx = para_calloc(sizeof(*ctx));
57 struct resample_filter_args_info *conf = fn->conf;
58 struct btr_node *btrn = fn->btrn;
59 struct wav_params wp;
60
61 fn->private_data = ctx;
62 fn->min_iqs = 2;
63 COPY_WAV_PARMS(&wp, conf);
64 ctx->cwc = check_wav_init(btr_parent(btrn), btrn, &wp, NULL);
65 btr_log_tree(btr_parent(btr_parent(btrn)), LL_INFO);
66 }
67
68 static void resample_pre_select(struct sched *s, struct task *t)
69 {
70 struct filter_node *fn = container_of(t, struct filter_node, task);
71 struct resample_context *ctx = fn->private_data;
72 int ret = btr_node_status(fn->btrn, fn->min_iqs, BTR_NT_INTERNAL);
73
74 if (ret != 0)
75 return sched_min_delay(s);
76 check_wav_pre_select(s, ctx->cwc);
77 }
78
79 static int get_btr_val(const char *what, struct btr_node *btrn)
80 {
81 char *buf;
82 int32_t val;
83 int ret = btr_exec_up(btr_parent(btrn), what, &buf);
84
85 if (ret < 0) {
86 PARA_NOTICE_LOG("btr exec for \"%s\" failed\n", what);
87 return ret;
88 }
89 ret = para_atoi32(buf, &val);
90 free(buf);
91 return ret < 0? ret : val;
92 }
93
94 static int resample_set_params(struct filter_node *fn)
95 {
96 int ret;
97 struct resample_context *ctx = fn->private_data;
98 struct resample_filter_args_info *conf = fn->conf;
99 struct btr_node *btrn = fn->btrn;
100
101 ctx->channels = conf->channels_arg;
102 if (!conf->channels_given) {
103 ret = get_btr_val("channels", btrn);
104 if (ret >= 0)
105 ctx->channels = ret;
106 }
107
108 ctx->source_sample_rate = conf->sample_rate_arg;
109 if (!conf->sample_rate_given) {
110 ret = get_btr_val("sample_rate", btrn);
111 if (ret >= 0)
112 ctx->source_sample_rate = ret;
113 }
114 /* reject all sample formats except 16 bit signed, little endian */
115 ret = get_btr_val("sample_format", btrn);
116 if (ret >= 0 && ret != SF_S16_LE) {
117 const char *sample_formats[] = {SAMPLE_FORMATS};
118 PARA_ERROR_LOG("unsupported sample format: %s\n",
119 sample_formats[ret]);
120 return -ERRNO_TO_PARA_ERROR(EINVAL);
121 }
122 ctx->ratio = (float)conf->dest_sample_rate_arg / ctx->source_sample_rate;
123 return 1;
124 }
125
126 static int resample_init(struct filter_node *fn)
127 {
128 int ret, converter;
129 struct resample_context *ctx = fn->private_data;
130 struct resample_filter_args_info *conf = fn->conf;
131 struct btr_node *btrn = fn->btrn;
132
133 ret = -E_RESAMPLE_EOF;
134 if (btr_no_parent(btrn))
135 return ret;
136 if (btr_get_input_queue_size(btrn) == 0)
137 return 0;
138 ret = resample_set_params(fn);
139 if (ret < 0)
140 return ret;
141 switch (conf->converter_arg) {
142 case converter_arg_best:
143 converter = SRC_SINC_BEST_QUALITY;
144 break;
145 case converter_arg_medium:
146 converter = SRC_SINC_MEDIUM_QUALITY;
147 break;
148 case converter_arg_fastest:
149 converter = SRC_SINC_FASTEST;
150 break;
151 case converter_arg_zero_order_hold:
152 converter = SRC_ZERO_ORDER_HOLD;
153 break;
154 case converter_arg_linear:
155 converter = SRC_LINEAR;
156 break;
157 default:
158 assert(0);
159 }
160 ctx->src_state = src_new(converter, conf->channels_arg, &ret);
161 if (!ctx->src_state) {
162 PARA_ERROR_LOG("%s\n", src_strerror(ret));
163 return -E_LIBSAMPLERATE;
164 }
165 fn->min_iqs = 2 * ctx->channels;
166 return 1;
167 }
168
169 /* returns number of input frames used */
170 static int resample_frames(int16_t *in, size_t num_frames, bool have_more,
171 struct resample_context *ctx, int16_t **result,
172 size_t *result_frames)
173 {
174 int ret, num_samples, out_samples;
175 int16_t *out;
176 SRC_DATA data;
177
178 data.src_ratio = ctx->ratio;
179 data.end_of_input = !have_more;
180
181 data.input_frames = num_frames;
182 num_samples = num_frames * ctx->channels;
183 data.output_frames = num_frames * ctx->ratio + 1;
184 out_samples = data.output_frames * ctx->channels;
185
186 data.data_in = para_malloc(num_samples * sizeof(float));
187 src_short_to_float_array(in, data.data_in, num_samples);
188 data.data_out = para_malloc(out_samples * sizeof(float));
189 ret = src_process(ctx->src_state, &data);
190 free(data.data_in);
191 if (ret != 0) {
192 PARA_ERROR_LOG("%s\n", src_strerror(ret));
193 free(data.data_out);
194 return -E_LIBSAMPLERATE;
195 }
196 out_samples = data.output_frames_gen * ctx->channels;
197 out = para_malloc(out_samples * sizeof(short));
198 src_float_to_short_array(data.data_out, out, out_samples);
199 free(data.data_out);
200 *result = out;
201 *result_frames = data.output_frames_gen;
202 return data.input_frames_used;
203 }
204
205 static int resample_post_select(__a_unused struct sched *s, struct task *t)
206 {
207 int ret;
208 struct filter_node *fn = container_of(t, struct filter_node, task);
209 struct resample_context *ctx = fn->private_data;
210 struct resample_filter_args_info *conf = fn->conf;
211 struct btr_node *btrn = fn->btrn;
212 int16_t *in, *out;
213 size_t in_bytes, num_frames;
214 bool have_more;
215
216 ret = check_wav_post_select(ctx->cwc);
217 if (ret < 0)
218 goto out;
219 if (!ctx->src_state) {
220 ret = resample_init(fn);
221 if (ret <= 0)
222 goto out;
223 }
224 ret = btr_node_status(btrn, fn->min_iqs, BTR_NT_INTERNAL);
225 if (ret <= 0)
226 goto out;
227 if (ctx->source_sample_rate == conf->dest_sample_rate_arg) {
228 /*
229 * No resampling necessary. We do not splice ourselves out
230 * though, since our children might want to ask us through the
231 * btr exec mechanism for the destination samplerate and the
232 * channel count.
233 */
234 btr_pushdown(btrn);
235 return 0;
236 }
237 btr_merge(btrn, fn->min_iqs);
238 in_bytes = btr_next_buffer(btrn, (char **)&in);
239 ret = -E_RESAMPLE_EOF;
240 num_frames = in_bytes / 2 / ctx->channels;
241 if (num_frames == 0)
242 goto out;
243 have_more = !btr_no_parent(btrn) ||
244 btr_next_buffer_omit(btrn, in_bytes, NULL) > 0;
245 ret = resample_frames(in, num_frames, have_more, ctx, &out, &num_frames);
246 if (ret < 0)
247 goto out;
248 btr_consume(btrn, ret * 2 * ctx->channels);
249 btr_add_output((char *)out, num_frames * 2 * ctx->channels, btrn);
250 return 0;
251 out:
252 if (ret < 0) {
253 btr_remove_node(&fn->btrn);
254 /* This releases the check_wav btr node */
255 check_wav_post_select(ctx->cwc);
256 }
257 return ret;
258 }
259
260 static int resample_parse_config(int argc, char **argv, void **config)
261 {
262 int ret, val, given;
263 struct resample_filter_args_info *conf = para_calloc(sizeof(*conf));
264
265 resample_filter_cmdline_parser(argc, argv, conf);
266
267 /* sanity checks */
268 ret = -ERRNO_TO_PARA_ERROR(EINVAL);
269 val = conf->channels_arg;
270 given = conf->channels_given;
271 if (val < 0 || (val == 0 && given))
272 goto err;
273 val = conf->sample_rate_arg;
274 given = conf->sample_rate_given;
275 if (val < 0 || (val == 0 && given))
276 goto err;
277 val = conf->dest_sample_rate_arg;
278 given = conf->dest_sample_rate_given;
279 if (val < 0 || (val == 0 && given))
280 goto err;
281 *config = conf;
282 return 1;
283 err:
284 free(conf);
285 return ret;
286 }
287
288 static void resample_free_config(void *conf)
289 {
290 if (!conf)
291 return;
292 resample_filter_cmdline_parser_free(conf);
293 free(conf);
294 }
295
296 /**
297 * The init function of the resample filter.
298 *
299 * \param f Structure to initialize.
300 */
301 void resample_filter_init(struct filter *f)
302 {
303 struct resample_filter_args_info dummy;
304
305 resample_filter_cmdline_parser_init(&dummy);
306 f->close = resample_close;
307 f->open = resample_open;
308 f->pre_select = resample_pre_select;
309 f->post_select = resample_post_select;
310 f->parse_config = resample_parse_config;
311 f->free_config = resample_free_config;
312 f->execute = resample_execute;
313 f->help = (struct ggo_help)DEFINE_GGO_HELP(resample_filter);
314 }