git.sesse.net Git - ffmpeg/blob - libavfilter/asrc_hilbert.c

   1 /*
   2  * Copyright (c) 2018 Paul B Mahol
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public License
   8  * as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/opt.h"
  22 #include "audio.h"
  23 #include "avfilter.h"
  24 #include "internal.h"
  25 #include "window_func.h"
  26
  27 typedef struct HilbertContext {
  28     const AVClass *class;
  29
  30     int sample_rate;
  31     int nb_taps;
  32     int nb_samples;
  33     int win_func;
  34
  35     float *taps;
  36     int64_t pts;
  37 } HilbertContext;
  38
  39 #define OFFSET(x) offsetof(HilbertContext, x)
  40 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
  41
  42 static const AVOption hilbert_options[] = {
  43     { "sample_rate", "set sample rate",    OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100},  1, INT_MAX,    FLAGS },
  44     { "r",           "set sample rate",    OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100},  1, INT_MAX,    FLAGS },
  45     { "taps",        "set number of taps", OFFSET(nb_taps),     AV_OPT_TYPE_INT, {.i64=22051}, 11, UINT16_MAX, FLAGS },
  46     { "t",           "set number of taps", OFFSET(nb_taps),     AV_OPT_TYPE_INT, {.i64=22051}, 11, UINT16_MAX, FLAGS },
  47     { "nb_samples",  "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
  48     { "n",           "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
  49     { "win_func", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" },
  50     { "w",        "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" },
  51         { "rect",     "Rectangular",      0, AV_OPT_TYPE_CONST, {.i64=WFUNC_RECT},     0, 0, FLAGS, "win_func" },
  52         { "bartlett", "Bartlett",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BARTLETT}, 0, 0, FLAGS, "win_func" },
  53         { "hanning",  "Hanning",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HANNING},  0, 0, FLAGS, "win_func" },
  54         { "hamming",  "Hamming",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HAMMING},  0, 0, FLAGS, "win_func" },
  55         { "blackman", "Blackman",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BLACKMAN}, 0, 0, FLAGS, "win_func" },
  56         { "welch",    "Welch",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_WELCH},    0, 0, FLAGS, "win_func" },
  57         { "flattop",  "Flat-top",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_FLATTOP},  0, 0, FLAGS, "win_func" },
  58         { "bharris",  "Blackman-Harris",  0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHARRIS},  0, 0, FLAGS, "win_func" },
  59         { "bnuttall", "Blackman-Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BNUTTALL}, 0, 0, FLAGS, "win_func" },
  60         { "bhann",    "Bartlett-Hann",    0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHANN},    0, 0, FLAGS, "win_func" },
  61         { "sine",     "Sine",             0, AV_OPT_TYPE_CONST, {.i64=WFUNC_SINE},     0, 0, FLAGS, "win_func" },
  62         { "nuttall",  "Nuttall",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_NUTTALL},  0, 0, FLAGS, "win_func" },
  63         { "lanczos",  "Lanczos",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_LANCZOS},  0, 0, FLAGS, "win_func" },
  64         { "gauss",    "Gauss",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_GAUSS},    0, 0, FLAGS, "win_func" },
  65         { "tukey",    "Tukey",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_TUKEY},    0, 0, FLAGS, "win_func" },
  66         { "dolph",    "Dolph-Chebyshev",  0, AV_OPT_TYPE_CONST, {.i64=WFUNC_DOLPH},    0, 0, FLAGS, "win_func" },
  67         { "cauchy",   "Cauchy",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_CAUCHY},   0, 0, FLAGS, "win_func" },
  68         { "parzen",   "Parzen",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_PARZEN},   0, 0, FLAGS, "win_func" },
  69         { "poisson",  "Poisson",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_POISSON},  0, 0, FLAGS, "win_func" },
  70         { "bohman" ,  "Bohman",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BOHMAN},   0, 0, FLAGS, "win_func" },
  71     {NULL}
  72 };
  73
  74 AVFILTER_DEFINE_CLASS(hilbert);
  75
  76 static av_cold int init(AVFilterContext *ctx)
  77 {
  78     HilbertContext *s = ctx->priv;
  79
  80     if (!(s->nb_taps & 1)) {
  81         av_log(s, AV_LOG_ERROR, "Number of taps %d must be odd length.\n", s->nb_taps);
  82         return AVERROR(EINVAL);
  83     }
  84
  85     return 0;
  86 }
  87
  88 static av_cold void uninit(AVFilterContext *ctx)
  89 {
  90     HilbertContext *s = ctx->priv;
  91
  92     av_freep(&s->taps);
  93 }
  94
  95 static av_cold int query_formats(AVFilterContext *ctx)
  96 {
  97     HilbertContext *s = ctx->priv;
  98     static const int64_t chlayouts[] = { AV_CH_LAYOUT_MONO, -1 };
  99     int sample_rates[] = { s->sample_rate, -1 };
 100     static const enum AVSampleFormat sample_fmts[] = {
 101         AV_SAMPLE_FMT_FLT,
 102         AV_SAMPLE_FMT_NONE
 103     };
 104
 105     AVFilterFormats *formats;
 106     AVFilterChannelLayouts *layouts;
 107     int ret;
 108
 109     formats = ff_make_format_list(sample_fmts);
 110     if (!formats)
 111         return AVERROR(ENOMEM);
 112     ret = ff_set_common_formats (ctx, formats);
 113     if (ret < 0)
 114         return ret;
 115
 116     layouts = ff_make_format64_list(chlayouts);
 117     if (!layouts)
 118         return AVERROR(ENOMEM);
 119     ret = ff_set_common_channel_layouts(ctx, layouts);
 120     if (ret < 0)
 121         return ret;
 122
 123     formats = ff_make_format_list(sample_rates);
 124     if (!formats)
 125         return AVERROR(ENOMEM);
 126     return ff_set_common_samplerates(ctx, formats);
 127 }
 128
 129 static av_cold int config_props(AVFilterLink *outlink)
 130 {
 131     AVFilterContext *ctx = outlink->src;
 132     HilbertContext *s = ctx->priv;
 133     float overlap;
 134     int i;
 135
 136     s->taps = av_malloc_array(s->nb_taps, sizeof(*s->taps));
 137     if (!s->taps)
 138         return AVERROR(ENOMEM);
 139
 140     generate_window_func(s->taps, s->nb_taps, s->win_func, &overlap);
 141
 142     for (i = 0; i < s->nb_taps; i++) {
 143         int k = -(s->nb_taps / 2) + i;
 144
 145         if (k & 1) {
 146             float pk = M_PI * k;
 147
 148             s->taps[i] *= (1.f - cosf(pk)) / pk;
 149         } else {
 150             s->taps[i] = 0.f;
 151         }
 152     }
 153
 154     s->pts = 0;
 155
 156     return 0;
 157 }
 158
 159 static int request_frame(AVFilterLink *outlink)
 160 {
 161     AVFilterContext *ctx = outlink->src;
 162     HilbertContext *s = ctx->priv;
 163     AVFrame *frame;
 164     int nb_samples;
 165
 166     nb_samples = FFMIN(s->nb_samples, s->nb_taps - s->pts);
 167     if (!nb_samples)
 168         return AVERROR_EOF;
 169
 170     if (!(frame = ff_get_audio_buffer(outlink, nb_samples)))
 171         return AVERROR(ENOMEM);
 172
 173     memcpy(frame->data[0], s->taps + s->pts, nb_samples * sizeof(float));
 174
 175     frame->pts = s->pts;
 176     s->pts    += nb_samples;
 177     return ff_filter_frame(outlink, frame);
 178 }
 179
 180 static const AVFilterPad hilbert_outputs[] = {
 181     {
 182         .name          = "default",
 183         .type          = AVMEDIA_TYPE_AUDIO,
 184         .request_frame = request_frame,
 185         .config_props  = config_props,
 186     },
 187     { NULL }
 188 };
 189
 190 AVFilter ff_asrc_hilbert = {
 191     .name          = "hilbert",
 192     .description   = NULL_IF_CONFIG_SMALL("Generate a Hilbert transform FIR coefficients."),
 193     .query_formats = query_formats,
 194     .init          = init,
 195     .uninit        = uninit,
 196     .priv_size     = sizeof(HilbertContext),
 197     .inputs        = NULL,
 198     .outputs       = hilbert_outputs,
 199     .priv_class    = &hilbert_class,
 200 };