resample_filter.c

   1 /*
   2  * Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>
   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, void *context)
  69 {
  70         struct filter_node *fn = context;
  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
 132         ret = resample_set_params(fn);
 133         if (ret < 0)
 134                 return ret;
 135         switch (conf->converter_arg) {
 136         case converter_arg_best:
 137                 converter = SRC_SINC_BEST_QUALITY;
 138                 break;
 139         case converter_arg_medium:
 140                 converter = SRC_SINC_MEDIUM_QUALITY;
 141                 break;
 142         case converter_arg_fastest:
 143                 converter = SRC_SINC_FASTEST;
 144                 break;
 145         case converter_arg_zero_order_hold:
 146                 converter = SRC_ZERO_ORDER_HOLD;
 147                 break;
 148         case converter_arg_linear:
 149                 converter = SRC_LINEAR;
 150                 break;
 151         default:
 152                 assert(0);
 153         }
 154         ctx->src_state = src_new(converter, conf->channels_arg, &ret);
 155         if (!ctx->src_state) {
 156                 PARA_ERROR_LOG("%s\n", src_strerror(ret));
 157                 return -E_LIBSAMPLERATE;
 158         }
 159         fn->min_iqs = 2 * ctx->channels;
 160         return 1;
 161 }
 162
 163 /* returns number of input frames used */
 164 static int resample_frames(int16_t *in, size_t num_frames, bool have_more,
 165                 struct resample_context *ctx, int16_t **result,
 166                 size_t *result_frames)
 167 {
 168         int ret, num_samples, out_samples;
 169         int16_t *out;
 170         SRC_DATA data;
 171
 172         data.src_ratio = ctx->ratio;
 173         data.end_of_input = !have_more;
 174
 175         data.input_frames = num_frames;
 176         num_samples = num_frames * ctx->channels;
 177         data.output_frames = num_frames * ctx->ratio + 1;
 178         out_samples = data.output_frames * ctx->channels;
 179
 180         data.data_in = para_malloc(num_samples * sizeof(float));
 181         src_short_to_float_array(in, data.data_in, num_samples);
 182         data.data_out = para_malloc(out_samples * sizeof(float));
 183         ret = src_process(ctx->src_state, &data);
 184         free(data.data_in);
 185         if (ret != 0) {
 186                 PARA_ERROR_LOG("%s\n", src_strerror(ret));
 187                 free(data.data_out);
 188                 return -E_LIBSAMPLERATE;
 189         }
 190         out_samples = data.output_frames_gen * ctx->channels;
 191         out = para_malloc(out_samples * sizeof(short));
 192         src_float_to_short_array(data.data_out, out, out_samples);
 193         free(data.data_out);
 194         *result = out;
 195         *result_frames = data.output_frames_gen;
 196         return data.input_frames_used;
 197 }
 198
 199 static int resample_post_select(__a_unused struct sched *s, void *context)
 200 {
 201         int ret;
 202         struct filter_node *fn = context;
 203         struct resample_context *ctx = fn->private_data;
 204         struct resample_filter_args_info *conf = fn->conf;
 205         struct btr_node *btrn = fn->btrn;
 206         int16_t *in, *out;
 207         size_t in_bytes, num_frames;
 208         bool have_more;
 209
 210         ret = check_wav_post_select(ctx->cwc);
 211         if (ret < 0)
 212                 goto out;
 213         ret = btr_node_status(btrn, fn->min_iqs, BTR_NT_INTERNAL);
 214         if (ret <= 0)
 215                 goto out;
 216         if (!ctx->src_state) {
 217                 ret = resample_init(fn);
 218                 if (ret <= 0)
 219                         goto out;
 220         }
 221         if (ctx->source_sample_rate == conf->dest_sample_rate_arg) {
 222                 /*
 223                  * No resampling necessary. We do not splice ourselves out
 224                  * though, since our children might want to ask us through the
 225                  * btr exec mechanism for the destination samplerate and the
 226                  * channel count.
 227                  */
 228                 btr_pushdown(btrn);
 229                 return 0;
 230         }
 231         btr_merge(btrn, fn->min_iqs);
 232         in_bytes = btr_next_buffer(btrn, (char **)&in);
 233         ret = -E_RESAMPLE_EOF;
 234         num_frames = in_bytes / 2 / ctx->channels;
 235         if (num_frames == 0)
 236                 goto out;
 237         have_more = !btr_no_parent(btrn) ||
 238                 btr_next_buffer_omit(btrn, in_bytes, NULL) > 0;
 239         ret = resample_frames(in, num_frames, have_more, ctx, &out, &num_frames);
 240         if (ret < 0)
 241                 goto out;
 242         btr_consume(btrn, ret * 2 * ctx->channels);
 243         btr_add_output((char *)out, num_frames * 2 * ctx->channels, btrn);
 244         return 0;
 245 out:
 246         if (ret < 0) {
 247                 btr_remove_node(&fn->btrn);
 248                 /* This releases the check_wav btr node */
 249                 check_wav_post_select(ctx->cwc);
 250         }
 251         return ret;
 252 }
 253
 254 static int resample_parse_config(int argc, char **argv, void **config)
 255 {
 256         int ret, val, given;
 257         struct resample_filter_args_info *conf = para_calloc(sizeof(*conf));
 258
 259         resample_filter_cmdline_parser(argc, argv, conf);
 260
 261         /* sanity checks */
 262         ret = -ERRNO_TO_PARA_ERROR(EINVAL);
 263         val = conf->channels_arg;
 264         given = conf->channels_given;
 265         if (val < 0 || (val == 0 && given))
 266                 goto err;
 267         val = conf->sample_rate_arg;
 268         given = conf->sample_rate_given;
 269         if (val < 0 || (val == 0 && given))
 270                 goto err;
 271         val = conf->dest_sample_rate_arg;
 272         given = conf->dest_sample_rate_given;
 273         if (val < 0 || (val == 0 && given))
 274                 goto err;
 275         *config = conf;
 276         return 1;
 277 err:
 278         free(conf);
 279         return ret;
 280 }
 281
 282 static void resample_free_config(void *conf)
 283 {
 284         if (!conf)
 285                 return;
 286         resample_filter_cmdline_parser_free(conf);
 287         free(conf);
 288 }
 289
 290 /**
 291  * The init function of the resample filter.
 292  *
 293  * \param f Structure to initialize.
 294  */
 295 void resample_filter_init(struct filter *f)
 296 {
 297         struct resample_filter_args_info dummy;
 298
 299         resample_filter_cmdline_parser_init(&dummy);
 300         f->close = resample_close;
 301         f->open = resample_open;
 302         f->pre_select = resample_pre_select;
 303         f->post_select = resample_post_select;
 304         f->parse_config = resample_parse_config;
 305         f->free_config = resample_free_config;
 306         f->execute = resample_execute;
 307         f->help = (struct ggo_help)DEFINE_GGO_HELP(resample_filter);
 308 }