From patchwork Mon Jan 1 16:02:13 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul B Mahol X-Patchwork-Id: 7060 Delivered-To: ffmpegpatchwork@gmail.com Received: by 10.2.79.195 with SMTP id r64csp13730071jad; Mon, 1 Jan 2018 08:03:20 -0800 (PST) X-Google-Smtp-Source: ACJfBouceGpiW9s4Evei7tkZIiPudHftxXvLvY8U3jI7rn1JlNbt5e5DaIvNLZ1da9rn8b2zJ8tC X-Received: by 10.223.182.160 with SMTP id j32mr40995497wre.159.1514822600838; Mon, 01 Jan 2018 08:03:20 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1514822600; cv=none; d=google.com; s=arc-20160816; b=cWmGobe3x7GFumuuhgTew3VLjx3qfbh8S0U9dqmGvWWQya5uz5zz2OLqdvXmNJ7MZI QUOL2pAoRTN9Hkr5IPXJRMSXnuKdut1PKNZ++nr+QO+dKBgY5fOYlKabohmu/iN4l7cv BXC1M9OpNa3TsKziHcuAOtOgrQAONzkdY5HBZyHouuXvrq9CDHNEK2i6/XwMVPgbZmq1 Djsdpc2K7QB1fulzJ4O4OGUvO9w/ZWnlFIQWlJ89sXI7pMQGi2xYp2727V2g2jqDjpbd CSyT8m+tigcdcQVgsE+NgJxPmJymk3VXQ4tKa3RefDLum8njM1hfOfQ7xhloVI0zZfc2 Meiw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:mime-version:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:message-id:date:to:from:dkim-signature :delivered-to:arc-authentication-results; bh=7r/1KALyFQk8oJSpMBancbSUmVUfi96436Q1XIjJbwE=; b=jJEnbvid9hhflDPj/GyYeUI5D+RnhVVZ17fLoNl7rhABdH51UAvZqd7+kmzw86AjOE UMcY0X3yNGLtpIgkeGiR2XC+9H/zCA7X244CMKvA/TTq6yuHdHdR7UZg4D584ixI0EpS nctvrNZaolMEwTQqDqF9XKPkXTHFjdAYbdVbvGetN4j88mms477QoCQIC8ySlWlddTQK pUa2OwlpG5t/Zq/r50IQB2wCmwAhc03mn1PAUpTuNlvPw0gJZOC6oX5NZTN3vmgl8nX2 Jc1ZXtj7iWun1TU2IvgXX2VR+Oe6bWM05G2SityVs1Q3/r7NEivCXLTOEhQN3kVycodq dIEw== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20161025 header.b=EcG/nJoR; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id j26si27173769wre.336.2018.01.01.08.03.19; Mon, 01 Jan 2018 08:03:20 -0800 (PST) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20161025 header.b=EcG/nJoR; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id C06B2680D4E; Mon, 1 Jan 2018 18:03:02 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-wm0-f54.google.com (mail-wm0-f54.google.com [74.125.82.54]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 57092680718 for ; Mon, 1 Jan 2018 18:02:57 +0200 (EET) Received: by mail-wm0-f54.google.com with SMTP id y82so13520955wmg.1 for ; Mon, 01 Jan 2018 08:03:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id; bh=56wGtWPq0Fo0T7gdeaUFHc6Wa/2B8xNSuf0ZrsoSM68=; b=EcG/nJoR/XSHN2e4E/GrvtWTxkbVDzE/+i3oQvkHdskDyVVCUtYTPUqvAHv3SrggCZ jCwBNFy/lS34Q14sfu5E3m45+OU5HDR7A+HlaWUWXwvjfdGIKXI0tLQqKrpCpiP4gTfb YGOSTBnXsMGDj+frjRXL4z9k7LLzBIP8txtWbVMo+y6ZD+CuyARO93Nc2lyyeTV0bQsk bAM2ryUh1ChlZGFqKfYQnSQQRTSE6o5coNI2TON34iXvFZhnnqUjdrBxqaGTUP8bBYgp TnyDuPEpS5hLb7GxbMOJ95IcsWpPQi6/J3MSFn/8YsM1ivOyHCG7YGxMxDxBXWK76dP3 fKjA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id; bh=56wGtWPq0Fo0T7gdeaUFHc6Wa/2B8xNSuf0ZrsoSM68=; b=T2xfiV9+kqe50vWcSh0SlgCHEU5kc1V6wVNdgk9T0IKmNc0BR/zcZZnoUcFvC2mvLJ vcn9xJoK1foUBlM2asn7iDP96BmPvTCJMDV5P/pnaOsEA2WESiO46qfk2sLbtOkLBRw8 MFlSWH5d1bSRUqufZtrg1fcESV3nHCraVsmYzDUkRYkqXpHAzYooAMNZF4KMQ075x/5J HoIhA91DIeA48kbWf5qJUDavY2ABMS0n4IEJYLgLnPbjbQ2Bymir3BtjPNmiWRjiZzQb lZE66NFbbvgca+OfC9VQYR2tbBRPAAxD5zJpay/N4PtsHwZo1NT+SPpuqgm/yZSyEjEq 94QQ== X-Gm-Message-State: AKGB3mItvSbh7zT0o41riXZol2HcJ5SV/Rt7ONnsEZWNNn/dLdyte2jQ z+J14XYgJWOfxE6/vhjH59E49w== X-Received: by 10.80.146.227 with SMTP id l32mr59624823eda.114.1514822592245; Mon, 01 Jan 2018 08:03:12 -0800 (PST) Received: from localhost.localdomain ([94.250.174.60]) by smtp.gmail.com with ESMTPSA id y48sm35866005edd.77.2018.01.01.08.03.10 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 01 Jan 2018 08:03:11 -0800 (PST) From: Paul B Mahol To: ffmpeg-devel@ffmpeg.org Date: Mon, 1 Jan 2018 17:02:13 +0100 Message-Id: <20180101160213.29411-1-onemda@gmail.com> X-Mailer: git-send-email 2.11.0 Subject: [FFmpeg-devel] [PATCH] avfilter: add hilbert source FIR filter X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Signed-off-by: Paul B Mahol --- doc/filters.texi | 28 +++++++ libavfilter/Makefile | 1 + libavfilter/allfilters.c | 1 + libavfilter/asrc_hilbert.c | 201 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 231 insertions(+) create mode 100644 libavfilter/asrc_hilbert.c diff --git a/doc/filters.texi b/doc/filters.texi index f651f1234d..f42f4c9190 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -926,6 +926,7 @@ afftfilt="1-clip((b/nb)*b,0,1)" @end example @end itemize +@anchor{afir} @section afir Apply an arbitrary Frequency Impulse Response filter. @@ -4873,6 +4874,33 @@ anoisesrc=d=60:c=pink:r=44100:a=0.5 @end example @end itemize +@section hilbert + +Generate an odd-tap Hilbert transform FIR coefficients. + +The resulted stream can be used with @ref{afir} filter for phase-shifting +the signal by 90 degrees. + +This is used in many matrix coding schemes and for analytic signal generation. +The process is often written as a multiplication by i (or j), the imaginary unit. + +The filter accepts the following options: + +@table @option + +@item sample_rate, s +Set sample rate, default is 44100. + +@item taps, t +Set length of FIR filter, default is 22051. + +@item nb_samples, n +Set number of samples per each frame. + +@item win_func, w +Set window function to be used when generating FIR coefficients. +@end table + @section sine Generate an audio signal made of a sine wave with amplitude 1/8. diff --git a/libavfilter/Makefile b/libavfilter/Makefile index 8bde542163..5eb331c961 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -126,6 +126,7 @@ OBJS-$(CONFIG_AEVALSRC_FILTER) += aeval.o OBJS-$(CONFIG_ANOISESRC_FILTER) += asrc_anoisesrc.o OBJS-$(CONFIG_ANULLSRC_FILTER) += asrc_anullsrc.o OBJS-$(CONFIG_FLITE_FILTER) += asrc_flite.o +OBJS-$(CONFIG_HILBERT_FILTER) += asrc_hilbert.o OBJS-$(CONFIG_SINE_FILTER) += asrc_sine.o OBJS-$(CONFIG_ANULLSINK_FILTER) += asink_anullsink.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index 67c073091f..7d5129d929 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -137,6 +137,7 @@ static void register_all(void) REGISTER_FILTER(ANOISESRC, anoisesrc, asrc); REGISTER_FILTER(ANULLSRC, anullsrc, asrc); REGISTER_FILTER(FLITE, flite, asrc); + REGISTER_FILTER(HILBERT, hilbert, asrc); REGISTER_FILTER(SINE, sine, asrc); REGISTER_FILTER(ANULLSINK, anullsink, asink); diff --git a/libavfilter/asrc_hilbert.c b/libavfilter/asrc_hilbert.c new file mode 100644 index 0000000000..1270a6b9f1 --- /dev/null +++ b/libavfilter/asrc_hilbert.c @@ -0,0 +1,201 @@ +/* + * Copyright (c) 2018 Paul B Mahol + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with FFmpeg; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "libavutil/opt.h" +#include "audio.h" +#include "avfilter.h" +#include "internal.h" +#include "window_func.h" + +typedef struct HilbertContext { + const AVClass *class; + + int sample_rate; + int nb_taps; + int nb_samples; + int win_func; + + float *taps; + int64_t pts; +} HilbertContext; + +#define OFFSET(x) offsetof(HilbertContext, x) +#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM + +static const AVOption hilbert_options[] = { + { "sample_rate", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT_MAX, FLAGS }, + { "r", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT_MAX, FLAGS }, + { "taps", "set number of taps", OFFSET(nb_taps), AV_OPT_TYPE_INT, {.i64=22051}, 11, UINT16_MAX, FLAGS }, + { "t", "set number of taps", OFFSET(nb_taps), AV_OPT_TYPE_INT, {.i64=22051}, 11, UINT16_MAX, FLAGS }, + { "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS }, + { "n", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS }, + { "win_func", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" }, + { "w", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" }, + { "rect", "Rectangular", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_RECT}, 0, 0, FLAGS, "win_func" }, + { "bartlett", "Bartlett", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BARTLETT}, 0, 0, FLAGS, "win_func" }, + { "hanning", "Hanning", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HANNING}, 0, 0, FLAGS, "win_func" }, + { "hamming", "Hamming", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HAMMING}, 0, 0, FLAGS, "win_func" }, + { "blackman", "Blackman", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BLACKMAN}, 0, 0, FLAGS, "win_func" }, + { "welch", "Welch", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_WELCH}, 0, 0, FLAGS, "win_func" }, + { "flattop", "Flat-top", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_FLATTOP}, 0, 0, FLAGS, "win_func" }, + { "bharris", "Blackman-Harris", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHARRIS}, 0, 0, FLAGS, "win_func" }, + { "bnuttall", "Blackman-Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BNUTTALL}, 0, 0, FLAGS, "win_func" }, + { "bhann", "Bartlett-Hann", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHANN}, 0, 0, FLAGS, "win_func" }, + { "sine", "Sine", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_SINE}, 0, 0, FLAGS, "win_func" }, + { "nuttall", "Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_NUTTALL}, 0, 0, FLAGS, "win_func" }, + { "lanczos", "Lanczos", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_LANCZOS}, 0, 0, FLAGS, "win_func" }, + { "gauss", "Gauss", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_GAUSS}, 0, 0, FLAGS, "win_func" }, + { "tukey", "Tukey", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_TUKEY}, 0, 0, FLAGS, "win_func" }, + { "dolph", "Dolph-Chebyshev", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_DOLPH}, 0, 0, FLAGS, "win_func" }, + { "cauchy", "Cauchy", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_CAUCHY}, 0, 0, FLAGS, "win_func" }, + { "parzen", "Parzen", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_PARZEN}, 0, 0, FLAGS, "win_func" }, + { "poisson", "Poisson", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_POISSON}, 0, 0, FLAGS, "win_func" }, + {NULL} +}; + +AVFILTER_DEFINE_CLASS(hilbert); + +static av_cold int init(AVFilterContext *ctx) +{ + HilbertContext *s = ctx->priv; + + if (!(s->nb_taps & 1)) { + av_log(s, AV_LOG_ERROR, "Number of taps %d must be odd length.\n", s->nb_taps); + return AVERROR(EINVAL); + } + + return 0; +} + +static av_cold void uninit(AVFilterContext *ctx) +{ + HilbertContext *s = ctx->priv; + + av_freep(&s->taps); +} + +static av_cold int query_formats(AVFilterContext *ctx) +{ + HilbertContext *s = ctx->priv; + static const int64_t chlayouts[] = { AV_CH_LAYOUT_MONO, -1 }; + int sample_rates[] = { s->sample_rate, -1 }; + static const enum AVSampleFormat sample_fmts[] = { + AV_SAMPLE_FMT_FLT, + AV_SAMPLE_FMT_NONE + }; + + AVFilterFormats *formats; + AVFilterChannelLayouts *layouts; + int ret; + + formats = ff_make_format_list(sample_fmts); + if (!formats) + return AVERROR(ENOMEM); + ret = ff_set_common_formats (ctx, formats); + if (ret < 0) + return ret; + + layouts = avfilter_make_format64_list(chlayouts); + if (!layouts) + return AVERROR(ENOMEM); + ret = ff_set_common_channel_layouts(ctx, layouts); + if (ret < 0) + return ret; + + formats = ff_make_format_list(sample_rates); + if (!formats) + return AVERROR(ENOMEM); + return ff_set_common_samplerates(ctx, formats); +} + +static av_cold int config_props(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + HilbertContext *s = ctx->priv; + float overlap; + int i; + + s->taps = av_malloc_array(s->nb_taps, sizeof(*s->taps)); + if (!s->taps) + return AVERROR(ENOMEM); + + generate_window_func(s->taps, s->nb_taps, s->win_func, &overlap); + + for (i = 0; i < s->nb_taps; i++) { + int k = -(s->nb_taps / 2) + i; + + if (k & 1) { + float pk = M_PI * k; + + s->taps[i] *= (1.f - cosf(pk)) / pk; + } else { + s->taps[i] = 0.f; + } + } + + s->pts = 0; + + return 0; +} + +static int request_frame(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + HilbertContext *s = ctx->priv; + AVFrame *frame; + int nb_samples; + float *dst; + + nb_samples = FFMIN(s->nb_samples, s->nb_taps - s->pts); + if (!nb_samples) + return AVERROR_EOF; + + if (!(frame = ff_get_audio_buffer(outlink, nb_samples))) + return AVERROR(ENOMEM); + + dst = (float *)frame->data[0]; + memcpy(frame->data[0], s->taps + s->pts, nb_samples * sizeof(float)); + + frame->pts = s->pts; + s->pts += nb_samples; + return ff_filter_frame(outlink, frame); +} + +static const AVFilterPad hilbert_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_AUDIO, + .request_frame = request_frame, + .config_props = config_props, + }, + { NULL } +}; + +AVFilter ff_asrc_hilbert = { + .name = "hilbert", + .description = NULL_IF_CONFIG_SMALL("Generate a Hilbert transform FIR coefficients."), + .query_formats = query_formats, + .init = init, + .uninit = uninit, + .priv_size = sizeof(HilbertContext), + .inputs = NULL, + .outputs = hilbert_outputs, + .priv_class = &hilbert_class, +};