History

avfilter: add speechnorm filter

Paul B Mahol committed 6 years ago

Commit 9f20e5d1 parent 46e362b6 files · +646 −1Browse files

Showing the changes to libavfilter (4 of 6 files). Show all

Unified · Split

4 files
  1. libavfilter/Makefile +1 −0
  2. libavfilter/af_speechnorm.c +579 −0
  3. libavfilter/allfilters.c +1 −0
  4. libavfilter/version.h +1 −1
libavfilter/Makefile+1−0
@@ -137,6 +137,7 @@ OBJS-$(CONFIG_SIDECHAINGATE_FILTER) += af_agate.o · 136 unmodified lines
137137 OBJS-$(CONFIG_SILENCEDETECT_FILTER) += af_silencedetect.o
138138 OBJS-$(CONFIG_SILENCEREMOVE_FILTER) += af_silenceremove.o
139139 OBJS-$(CONFIG_SOFALIZER_FILTER) += af_sofalizer.o
140+OBJS-$(CONFIG_SPEECHNORM_FILTER) += af_speechnorm.o
140141 OBJS-$(CONFIG_STEREOTOOLS_FILTER) += af_stereotools.o
141142 OBJS-$(CONFIG_STEREOWIDEN_FILTER) += af_stereowiden.o
142143 OBJS-$(CONFIG_SUPEREQUALIZER_FILTER) += af_superequalizer.o
libavfilter/af_speechnorm.c+579−0
@@ -0,0 +1,579 @@
1+/*
2+ * Copyright (c) 2020 Paul B Mahol
3+ *
4+ * Speech Normalizer
5+ *
6+ * This file is part of FFmpeg.
7+ *
8+ * FFmpeg is free software; you can redistribute it and/or
9+ * modify it under the terms of the GNU Lesser General Public
10+ * License as published by the Free Software Foundation; either
11+ * version 2.1 of the License, or (at your option) any later version.
12+ *
13+ * FFmpeg is distributed in the hope that it will be useful,
14+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16+ * Lesser General Public License for more details.
17+ *
18+ * You should have received a copy of the GNU Lesser General Public
19+ * License along with FFmpeg; if not, write to the Free Software
20+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21+ */
22+
23+/**
24+ * @file
25+ * Speech Normalizer
26+ */
27+
28+#include <float.h>
29+
30+#include "libavutil/avassert.h"
31+#include "libavutil/opt.h"
32+
33+#define FF_BUFQUEUE_SIZE (1024)
34+#include "bufferqueue.h"
35+
36+#include "audio.h"
37+#include "avfilter.h"
38+#include "filters.h"
39+#include "internal.h"
40+
41+#define MAX_ITEMS 882000
42+#define MIN_PEAK (1. / 32768.)
43+
44+typedef struct PeriodItem {
45+ int size;
46+ int type;
47+ double max_peak;
48+} PeriodItem;
49+
50+typedef struct ChannelContext {
51+ int state;
52+ int bypass;
53+ PeriodItem pi[MAX_ITEMS];
54+ double gain_state;
55+ double pi_max_peak;
56+ int pi_start;
57+ int pi_end;
58+ int pi_size;
59+} ChannelContext;
60+
61+typedef struct SpeechNormalizerContext {
62+ const AVClass *class;
63+
64+ double peak_value;
65+ double max_expansion;
66+ double max_compression;
67+ double threshold_value;
68+ double raise_amount;
69+ double fall_amount;
70+ uint64_t channels;
71+ int invert;
72+ int link;
73+
74+ ChannelContext *cc;
75+ double prev_gain;
76+
77+ int max_period;
78+ int eof;
79+ int64_t pts;
80+
81+ struct FFBufQueue queue;
82+
83+ void (*analyze_channel)(AVFilterContext *ctx, ChannelContext *cc,
84+ const uint8_t *srcp, int nb_samples);
85+ void (*filter_channels[2])(AVFilterContext *ctx,
86+ AVFrame *in, int nb_samples);
87+} SpeechNormalizerContext;
88+
89+#define OFFSET(x) offsetof(SpeechNormalizerContext, x)
90+#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
91+
92+static const AVOption speechnorm_options[] = {
93+ { "peak", "set the peak value", OFFSET(peak_value), AV_OPT_TYPE_DOUBLE, {.dbl=0.95}, 0.0, 1.0, FLAGS },
94+ { "p", "set the peak value", OFFSET(peak_value), AV_OPT_TYPE_DOUBLE, {.dbl=0.95}, 0.0, 1.0, FLAGS },
95+ { "expansion", "set the max expansion factor", OFFSET(max_expansion), AV_OPT_TYPE_DOUBLE, {.dbl=2.0}, 1.0, 50.0, FLAGS },
96+ { "e", "set the max expansion factor", OFFSET(max_expansion), AV_OPT_TYPE_DOUBLE, {.dbl=2.0}, 1.0, 50.0, FLAGS },
97+ { "compression", "set the max compression factor", OFFSET(max_compression), AV_OPT_TYPE_DOUBLE, {.dbl=2.0}, 1.0, 50.0, FLAGS },
98+ { "c", "set the max compression factor", OFFSET(max_compression), AV_OPT_TYPE_DOUBLE, {.dbl=2.0}, 1.0, 50.0, FLAGS },
99+ { "threshold", "set the threshold value", OFFSET(threshold_value), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0.0, 1.0, FLAGS },
100+ { "t", "set the threshold value", OFFSET(threshold_value), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0.0, 1.0, FLAGS },
101+ { "raise", "set the expansion raising amount", OFFSET(raise_amount), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0.0, 1.0, FLAGS },
102+ { "r", "set the expansion raising amount", OFFSET(raise_amount), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0.0, 1.0, FLAGS },
103+ { "fall", "set the compression raising amount", OFFSET(fall_amount), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0.0, 1.0, FLAGS },
104+ { "f", "set the compression raising amount", OFFSET(fall_amount), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0.0, 1.0, FLAGS },
105+ { "channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS },
106+ { "h", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS },
107+ { "invert", "set inverted filtering", OFFSET(invert), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
108+ { "i", "set inverted filtering", OFFSET(invert), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
109+ { "link", "set linked channels filtering", OFFSET(link), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
110+ { "l", "set linked channels filtering", OFFSET(link), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
111+ { NULL }
112+};
113+
114+AVFILTER_DEFINE_CLASS(speechnorm);
115+
116+static int query_formats(AVFilterContext *ctx)
117+{
118+ AVFilterFormats *formats;
119+ AVFilterChannelLayouts *layouts;
120+ static const enum AVSampleFormat sample_fmts[] = {
121+ AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
122+ AV_SAMPLE_FMT_NONE
123+ };
124+ int ret;
125+
126+ layouts = ff_all_channel_counts();
127+ if (!layouts)
128+ return AVERROR(ENOMEM);
129+ ret = ff_set_common_channel_layouts(ctx, layouts);
130+ if (ret < 0)
131+ return ret;
132+
133+ formats = ff_make_format_list(sample_fmts);
134+ if (!formats)
135+ return AVERROR(ENOMEM);
136+ ret = ff_set_common_formats(ctx, formats);
137+ if (ret < 0)
138+ return ret;
139+
140+ formats = ff_all_samplerates();
141+ if (!formats)
142+ return AVERROR(ENOMEM);
143+ return ff_set_common_samplerates(ctx, formats);
144+}
145+
146+static int get_pi_samples(PeriodItem *pi, int start, int end, int remain)
147+{
148+ int sum;
149+
150+ if (pi[start].type == 0)
151+ return remain;
152+
153+ sum = remain;
154+ while (start != end) {
155+ start++;
156+ if (start >= MAX_ITEMS)
157+ start = 0;
158+ if (pi[start].type == 0)
159+ break;
160+ av_assert0(pi[start].size > 0);
161+ sum += pi[start].size;
162+ }
163+
164+ return sum;
165+}
166+
167+static int available_samples(AVFilterContext *ctx)
168+{
169+ SpeechNormalizerContext *s = ctx->priv;
170+ AVFilterLink *inlink = ctx->inputs[0];
171+ int min_pi_nb_samples;
172+
173+ min_pi_nb_samples = get_pi_samples(s->cc[0].pi, s->cc[0].pi_start, s->cc[0].pi_end, s->cc[0].pi_size);
174+ for (int ch = 1; ch < inlink->channels && min_pi_nb_samples > 0; ch++) {
175+ ChannelContext *cc = &s->cc[ch];
176+
177+ min_pi_nb_samples = FFMIN(min_pi_nb_samples, get_pi_samples(cc->pi, cc->pi_start, cc->pi_end, cc->pi_size));
178+ }
179+
180+ return min_pi_nb_samples;
181+}
182+
183+static void consume_pi(ChannelContext *cc, int nb_samples)
184+{
185+ if (cc->pi_size >= nb_samples) {
186+ cc->pi_size -= nb_samples;
187+ } else {
188+ av_assert0(0);
189+ }
190+}
191+
192+static double next_gain(AVFilterContext *ctx, double pi_max_peak, int bypass, double state)
193+{
194+ SpeechNormalizerContext *s = ctx->priv;
195+ const double expansion = FFMIN(s->max_expansion, s->peak_value / pi_max_peak);
196+ const double compression = 1. / s->max_compression;
197+ const int type = s->invert ? pi_max_peak <= s->threshold_value : pi_max_peak >= s->threshold_value;
198+
199+ if (bypass) {
200+ return 1.;
201+ } else if (type) {
202+ return FFMIN(expansion, state + s->raise_amount);
203+ } else {
204+ return FFMIN(expansion, FFMAX(compression, state - s->fall_amount));
205+ }
206+}
207+
208+static void next_pi(AVFilterContext *ctx, ChannelContext *cc, int bypass)
209+{
210+ av_assert0(cc->pi_size >= 0);
211+ if (cc->pi_size == 0) {
212+ SpeechNormalizerContext *s = ctx->priv;
213+ int start = cc->pi_start;
214+
215+ av_assert0(cc->pi[start].size > 0);
216+ av_assert0(cc->pi[start].type > 0 || s->eof);
217+ cc->pi_size = cc->pi[start].size;
218+ cc->pi_max_peak = cc->pi[start].max_peak;
219+ av_assert0(cc->pi_start != cc->pi_end || s->eof);
220+ start++;
221+ if (start >= MAX_ITEMS)
222+ start = 0;
223+ cc->pi_start = start;
224+ cc->gain_state = next_gain(ctx, cc->pi_max_peak, bypass, cc->gain_state);
225+ }
226+}
227+
228+static double min_gain(AVFilterContext *ctx, ChannelContext *cc, int max_size)
229+{
230+ SpeechNormalizerContext *s = ctx->priv;
231+ double min_gain = s->max_expansion;
232+ double gain_state = cc->gain_state;
233+ int size = cc->pi_size;
234+ int idx = cc->pi_start;
235+
236+ min_gain = FFMIN(min_gain, gain_state);
237+ while (size <= max_size) {
238+ if (idx == cc->pi_end)
239+ break;
240+ gain_state = next_gain(ctx, cc->pi[idx].max_peak, 0, gain_state);
241+ min_gain = FFMIN(min_gain, gain_state);
242+ size += cc->pi[idx].size;
243+ idx++;
244+ if (idx >= MAX_ITEMS)
245+ idx = 0;
246+ }
247+
248+ return min_gain;
249+}
250+
251+#define ANALYZE_CHANNEL(name, ptype, zero) \
252+static void analyze_channel_## name (AVFilterContext *ctx, ChannelContext *cc, \
253+ const uint8_t *srcp, int nb_samples) \
254+{ \
255+ SpeechNormalizerContext *s = ctx->priv; \
256+ const ptype *src = (const ptype *)srcp; \
257+ int n = 0; \
258+ \
259+ if (cc->state < 0) \
260+ cc->state = src[0] >= zero; \
261+ \
262+ while (n < nb_samples) { \
263+ if ((cc->state != (src[n] >= zero)) || \
264+ (cc->pi[cc->pi_end].size > s->max_period)) { \
265+ double max_peak = cc->pi[cc->pi_end].max_peak; \
266+ int state = cc->state; \
267+ cc->state = src[n] >= zero; \
268+ av_assert0(cc->pi[cc->pi_end].size > 0); \
269+ if (cc->pi[cc->pi_end].max_peak >= MIN_PEAK || \
270+ cc->pi[cc->pi_end].size > s->max_period) { \
271+ cc->pi[cc->pi_end].type = 1; \
272+ cc->pi_end++; \
273+ if (cc->pi_end >= MAX_ITEMS) \
274+ cc->pi_end = 0; \
275+ if (cc->state != state) \
276+ cc->pi[cc->pi_end].max_peak = DBL_MIN; \
277+ else \
278+ cc->pi[cc->pi_end].max_peak = max_peak; \
279+ cc->pi[cc->pi_end].type = 0; \
280+ cc->pi[cc->pi_end].size = 0; \
281+ av_assert0(cc->pi_end != cc->pi_start); \
282+ } \
283+ } \
284+ \
285+ if (cc->state) { \
286+ while (src[n] >= zero) { \
287+ cc->pi[cc->pi_end].max_peak = FFMAX(cc->pi[cc->pi_end].max_peak, src[n]); \
288+ cc->pi[cc->pi_end].size++; \
289+ n++; \
290+ if (n >= nb_samples) \
291+ break; \
292+ } \
293+ } else { \
294+ while (src[n] < zero) { \
295+ cc->pi[cc->pi_end].max_peak = FFMAX(cc->pi[cc->pi_end].max_peak, -src[n]); \
296+ cc->pi[cc->pi_end].size++; \
297+ n++; \
298+ if (n >= nb_samples) \
299+ break; \
300+ } \
301+ } \
302+ } \
303+}
304+
305+ANALYZE_CHANNEL(dbl, double, 0.0)
306+ANALYZE_CHANNEL(flt, float, 0.f)
307+
308+#define FILTER_CHANNELS(name, ptype) \
309+static void filter_channels_## name (AVFilterContext *ctx, \
310+ AVFrame *in, int nb_samples) \
311+{ \
312+ SpeechNormalizerContext *s = ctx->priv; \
313+ AVFilterLink *inlink = ctx->inputs[0]; \
314+ \
315+ for (int ch = 0; ch < inlink->channels; ch++) { \
316+ ChannelContext *cc = &s->cc[ch]; \
317+ ptype *dst = (ptype *)in->extended_data[ch]; \
318+ const int bypass = !(av_channel_layout_extract_channel(inlink->channel_layout, ch) & s->channels); \
319+ int n = 0; \
320+ \
321+ while (n < nb_samples) { \
322+ ptype gain; \
323+ int size; \
324+ \
325+ next_pi(ctx, cc, bypass); \
326+ size = FFMIN(nb_samples - n, cc->pi_size); \
327+ av_assert0(size > 0); \
328+ gain = cc->gain_state; \
329+ consume_pi(cc, size); \
330+ for (int i = n; i < n + size; i++) \
331+ dst[i] *= gain; \
332+ n += size; \
333+ } \
334+ } \
335+}
336+
337+FILTER_CHANNELS(dbl, double)
338+FILTER_CHANNELS(flt, float)
339+
340+static double lerp(double min, double max, double mix)
341+{
342+ return min + (max - min) * mix;
343+}
344+
345+#define FILTER_LINK_CHANNELS(name, ptype) \
346+static void filter_link_channels_## name (AVFilterContext *ctx, \
347+ AVFrame *in, int nb_samples) \
348+{ \
349+ SpeechNormalizerContext *s = ctx->priv; \
350+ AVFilterLink *inlink = ctx->inputs[0]; \
351+ int n = 0; \
352+ \
353+ while (n < nb_samples) { \
354+ int min_size = nb_samples - n; \
355+ int max_size = 1; \
356+ ptype gain = s->max_expansion; \
357+ \
358+ for (int ch = 0; ch < inlink->channels; ch++) { \
359+ ChannelContext *cc = &s->cc[ch]; \
360+ \
361+ cc->bypass = !(av_channel_layout_extract_channel(inlink->channel_layout, ch) & s->channels); \
362+ \
363+ next_pi(ctx, cc, cc->bypass); \
364+ min_size = FFMIN(min_size, cc->pi_size); \
365+ max_size = FFMAX(max_size, cc->pi_size); \
366+ } \
367+ \
368+ av_assert0(min_size > 0); \
369+ for (int ch = 0; ch < inlink->channels; ch++) { \
370+ ChannelContext *cc = &s->cc[ch]; \
371+ \
372+ if (cc->bypass) \
373+ continue; \
374+ gain = FFMIN(gain, min_gain(ctx, cc, max_size)); \
375+ } \
376+ \
377+ for (int ch = 0; ch < inlink->channels; ch++) { \
378+ ChannelContext *cc = &s->cc[ch]; \
379+ ptype *dst = (ptype *)in->extended_data[ch]; \
380+ \
381+ consume_pi(cc, min_size); \
382+ if (cc->bypass) \
383+ continue; \
384+ \
385+ for (int i = n; i < n + min_size; i++) { \
386+ ptype g = lerp(s->prev_gain, gain, (i - n) / (double)min_size); \
387+ dst[i] *= g; \
388+ } \
389+ } \
390+ \
391+ s->prev_gain = gain; \
392+ n += min_size; \
393+ } \
394+}
395+
396+FILTER_LINK_CHANNELS(dbl, double)
397+FILTER_LINK_CHANNELS(flt, float)
398+
399+static int filter_frame(AVFilterContext *ctx)
400+{
401+ SpeechNormalizerContext *s = ctx->priv;
402+ AVFilterLink *outlink = ctx->outputs[0];
403+ AVFilterLink *inlink = ctx->inputs[0];
404+ int ret;
405+
406+ while (s->queue.available > 0) {
407+ int min_pi_nb_samples;
408+ AVFrame *in;
409+
410+ in = ff_bufqueue_peek(&s->queue, 0);
411+ if (!in)
412+ break;
413+
414+ min_pi_nb_samples = available_samples(ctx);
415+ if (min_pi_nb_samples < in->nb_samples && !s->eof)
416+ break;
417+
418+ in = ff_bufqueue_get(&s->queue);
419+
420+ av_frame_make_writable(in);
421+
422+ s->filter_channels[s->link](ctx, in, in->nb_samples);
423+
424+ s->pts = in->pts + in->nb_samples;
425+
426+ return ff_filter_frame(outlink, in);
427+ }
428+
429+ for (int f = 0; f < ff_inlink_queued_frames(inlink); f++) {
430+ AVFrame *in;
431+
432+ ret = ff_inlink_consume_frame(inlink, &in);
433+ if (ret < 0)
434+ return ret;
435+ if (ret == 0)
436+ break;
437+
438+ ff_bufqueue_add(ctx, &s->queue, in);
439+
440+ for (int ch = 0; ch < inlink->channels; ch++) {
441+ ChannelContext *cc = &s->cc[ch];
442+
443+ s->analyze_channel(ctx, cc, in->extended_data[ch], in->nb_samples);
444+ }
445+ }
446+
447+ return 1;
448+}
449+
450+static int activate(AVFilterContext *ctx)
451+{
452+ AVFilterLink *inlink = ctx->inputs[0];
453+ AVFilterLink *outlink = ctx->outputs[0];
454+ SpeechNormalizerContext *s = ctx->priv;
455+ int ret, status;
456+ int64_t pts;
457+
458+ FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
459+
460+ ret = filter_frame(ctx);
461+ if (ret <= 0)
462+ return ret;
463+
464+ if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
465+ if (status == AVERROR_EOF)
466+ s->eof = 1;
467+ }
468+
469+ if (s->eof && ff_inlink_queued_samples(inlink) == 0 &&
470+ s->queue.available == 0) {
471+ ff_outlink_set_status(outlink, AVERROR_EOF, s->pts);
472+ return 0;
473+ }
474+
475+ if (s->queue.available > 0) {
476+ AVFrame *in = ff_bufqueue_peek(&s->queue, 0);
477+ const int nb_samples = available_samples(ctx);
478+
479+ if (nb_samples >= in->nb_samples || s->eof) {
480+ ff_filter_set_ready(ctx, 10);
481+ return 0;
482+ }
483+ }
484+
485+ FF_FILTER_FORWARD_WANTED(outlink, inlink);
486+
487+ return FFERROR_NOT_READY;
488+}
489+
490+static int config_input(AVFilterLink *inlink)
491+{
492+ AVFilterContext *ctx = inlink->dst;
493+ SpeechNormalizerContext *s = ctx->priv;
494+
495+ s->max_period = inlink->sample_rate / 10;
496+
497+ s->prev_gain = 1.;
498+ s->cc = av_calloc(inlink->channels, sizeof(*s->cc));
499+ if (!s->cc)
500+ return AVERROR(ENOMEM);
501+
502+ for (int ch = 0; ch < inlink->channels; ch++) {
503+ ChannelContext *cc = &s->cc[ch];
504+
505+ cc->state = -1;
506+ cc->gain_state = 1.;
507+ }
508+
509+ switch (inlink->format) {
510+ case AV_SAMPLE_FMT_FLTP:
511+ s->analyze_channel = analyze_channel_flt;
512+ s->filter_channels[0] = filter_channels_flt;
513+ s->filter_channels[1] = filter_link_channels_flt;
514+ break;
515+ case AV_SAMPLE_FMT_DBLP:
516+ s->analyze_channel = analyze_channel_dbl;
517+ s->filter_channels[0] = filter_channels_dbl;
518+ s->filter_channels[1] = filter_link_channels_dbl;
519+ break;
520+ default:
521+ av_assert0(0);
522+ }
523+
524+ return 0;
525+}
526+
527+static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
528+ char *res, int res_len, int flags)
529+{
530+ SpeechNormalizerContext *s = ctx->priv;
531+ int link = s->link;
532+ int ret;
533+
534+ ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
535+ if (ret < 0)
536+ return ret;
537+ if (link != s->link)
538+ s->prev_gain = 1.;
539+
540+ return 0;
541+}
542+
543+static av_cold void uninit(AVFilterContext *ctx)
544+{
545+ SpeechNormalizerContext *s = ctx->priv;
546+
547+ ff_bufqueue_discard_all(&s->queue);
548+ av_freep(&s->cc);
549+}
550+
551+static const AVFilterPad inputs[] = {
552+ {
553+ .name = "default",
554+ .type = AVMEDIA_TYPE_AUDIO,
555+ .config_props = config_input,
556+ },
557+ { NULL }
558+};
559+
560+static const AVFilterPad outputs[] = {
561+ {
562+ .name = "default",
563+ .type = AVMEDIA_TYPE_AUDIO,
564+ },
565+ { NULL }
566+};
567+
568+AVFilter ff_af_speechnorm = {
569+ .name = "speechnorm",
570+ .description = NULL_IF_CONFIG_SMALL("Speech Normalizer."),
571+ .query_formats = query_formats,
572+ .priv_size = sizeof(SpeechNormalizerContext),
573+ .priv_class = &speechnorm_class,
574+ .activate = activate,
575+ .uninit = uninit,
576+ .inputs = inputs,
577+ .outputs = outputs,
578+ .process_command = process_command,
579+};
libavfilter/allfilters.c+1−0
@@ -131,6 +131,7 @@ extern AVFilter ff_af_sidechaingate; · 130 unmodified lines
131131 extern AVFilter ff_af_silencedetect;
132132 extern AVFilter ff_af_silenceremove;
133133 extern AVFilter ff_af_sofalizer;
134+extern AVFilter ff_af_speechnorm;
134135 extern AVFilter ff_af_stereotools;
135136 extern AVFilter ff_af_stereowiden;
136137 extern AVFilter ff_af_superequalizer;
libavfilter/version.h+1−1
@@ -30,7 +30,7 @@ · 29 unmodified lines
3030 #include "libavutil/version.h"
3131
3232 #define LIBAVFILTER_VERSION_MAJOR 7
33−#define LIBAVFILTER_VERSION_MINOR 89
33+#define LIBAVFILTER_VERSION_MINOR 90
3434 #define LIBAVFILTER_VERSION_MICRO 100
3535
3636

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t