Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Copyright (c) 2001-2010 Krzysztof Foltman, Markus Schmidt, Thor Harald Johansen and others | ||
3 | * Copyright (c) 2015 Paul B Mahol | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | #include "libavutil/intreadwrite.h" | ||
23 | #include "libavutil/avstring.h" | ||
24 | #include "libavutil/ffmath.h" | ||
25 | #include "libavutil/mem.h" | ||
26 | #include "libavutil/opt.h" | ||
27 | #include "libavutil/parseutils.h" | ||
28 | #include "avfilter.h" | ||
29 | #include "formats.h" | ||
30 | #include "internal.h" | ||
31 | #include "audio.h" | ||
32 | #include "video.h" | ||
33 | |||
34 | #define FILTER_ORDER 4 | ||
35 | |||
36 | enum FilterType { | ||
37 | BUTTERWORTH, | ||
38 | CHEBYSHEV1, | ||
39 | CHEBYSHEV2, | ||
40 | NB_TYPES | ||
41 | }; | ||
42 | |||
43 | typedef struct FoSection { | ||
44 | double a0, a1, a2, a3, a4; | ||
45 | double b0, b1, b2, b3, b4; | ||
46 | |||
47 | double num[4]; | ||
48 | double denum[4]; | ||
49 | } FoSection; | ||
50 | |||
51 | typedef struct EqualizatorFilter { | ||
52 | int ignore; | ||
53 | int channel; | ||
54 | int type; | ||
55 | |||
56 | double freq; | ||
57 | double gain; | ||
58 | double width; | ||
59 | |||
60 | FoSection section[2]; | ||
61 | } EqualizatorFilter; | ||
62 | |||
63 | typedef struct AudioNEqualizerContext { | ||
64 | const AVClass *class; | ||
65 | char *args; | ||
66 | char *colors; | ||
67 | int draw_curves; | ||
68 | int w, h; | ||
69 | |||
70 | double mag; | ||
71 | int fscale; | ||
72 | int nb_filters; | ||
73 | int nb_allocated; | ||
74 | EqualizatorFilter *filters; | ||
75 | AVFrame *video; | ||
76 | } AudioNEqualizerContext; | ||
77 | |||
78 | #define OFFSET(x) offsetof(AudioNEqualizerContext, x) | ||
79 | #define A AV_OPT_FLAG_AUDIO_PARAM | ||
80 | #define V AV_OPT_FLAG_VIDEO_PARAM | ||
81 | #define F AV_OPT_FLAG_FILTERING_PARAM | ||
82 | |||
83 | static const AVOption anequalizer_options[] = { | ||
84 | { "params", NULL, OFFSET(args), AV_OPT_TYPE_STRING, {.str=""}, 0, 0, A|F }, | ||
85 | { "curves", "draw frequency response curves", OFFSET(draw_curves), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, V|F }, | ||
86 | { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "hd720"}, 0, 0, V|F }, | ||
87 | { "mgain", "set max gain", OFFSET(mag), AV_OPT_TYPE_DOUBLE, {.dbl=60}, -900, 900, V|F }, | ||
88 | { "fscale", "set frequency scale", OFFSET(fscale), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, V|F, .unit = "fscale" }, | ||
89 | { "lin", "linear", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, V|F, .unit = "fscale" }, | ||
90 | { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, V|F, .unit = "fscale" }, | ||
91 | { "colors", "set channels curves colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, V|F }, | ||
92 | { NULL } | ||
93 | }; | ||
94 | |||
95 | AVFILTER_DEFINE_CLASS(anequalizer); | ||
96 | |||
97 | ✗ | static void draw_curves(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *out) | |
98 | { | ||
99 | ✗ | AudioNEqualizerContext *s = ctx->priv; | |
100 | ✗ | char *colors, *color, *saveptr = NULL; | |
101 | int ch, i, n; | ||
102 | |||
103 | ✗ | colors = av_strdup(s->colors); | |
104 | ✗ | if (!colors) | |
105 | ✗ | return; | |
106 | |||
107 | ✗ | memset(out->data[0], 0, s->h * out->linesize[0]); | |
108 | |||
109 | ✗ | for (ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { | |
110 | ✗ | uint8_t fg[4] = { 0xff, 0xff, 0xff, 0xff }; | |
111 | ✗ | int prev_v = -1; | |
112 | double f; | ||
113 | |||
114 | ✗ | color = av_strtok(ch == 0 ? colors : NULL, " |", &saveptr); | |
115 | ✗ | if (color) | |
116 | ✗ | av_parse_color(fg, color, -1, ctx); | |
117 | |||
118 | ✗ | for (f = 0; f < s->w; f++) { | |
119 | double zr, zi, zr2, zi2; | ||
120 | double Hr, Hi; | ||
121 | ✗ | double Hmag = 1; | |
122 | double w; | ||
123 | int v, y, x; | ||
124 | |||
125 | ✗ | w = M_PI * (s->fscale ? pow(s->w - 1, f / s->w) : f) / (s->w - 1); | |
126 | ✗ | zr = cos(w); | |
127 | ✗ | zr2 = zr * zr; | |
128 | ✗ | zi = -sin(w); | |
129 | ✗ | zi2 = zi * zi; | |
130 | |||
131 | ✗ | for (n = 0; n < s->nb_filters; n++) { | |
132 | ✗ | if (s->filters[n].channel != ch || | |
133 | ✗ | s->filters[n].ignore) | |
134 | ✗ | continue; | |
135 | |||
136 | ✗ | for (i = 0; i < FILTER_ORDER / 2; i++) { | |
137 | ✗ | FoSection *S = &s->filters[n].section[i]; | |
138 | |||
139 | /* H *= (((((S->b4 * z + S->b3) * z + S->b2) * z + S->b1) * z + S->b0) / | ||
140 | ((((S->a4 * z + S->a3) * z + S->a2) * z + S->a1) * z + S->a0)); */ | ||
141 | |||
142 | ✗ | Hr = S->b4*(1-8*zr2*zi2) + S->b2*(zr2-zi2) + zr*(S->b1+S->b3*(zr2-3*zi2))+ S->b0; | |
143 | ✗ | Hi = zi*(S->b3*(3*zr2-zi2) + S->b1 + 2*zr*(2*S->b4*(zr2-zi2) + S->b2)); | |
144 | ✗ | Hmag *= hypot(Hr, Hi); | |
145 | ✗ | Hr = S->a4*(1-8*zr2*zi2) + S->a2*(zr2-zi2) + zr*(S->a1+S->a3*(zr2-3*zi2))+ S->a0; | |
146 | ✗ | Hi = zi*(S->a3*(3*zr2-zi2) + S->a1 + 2*zr*(2*S->a4*(zr2-zi2) + S->a2)); | |
147 | ✗ | Hmag /= hypot(Hr, Hi); | |
148 | } | ||
149 | } | ||
150 | |||
151 | ✗ | v = av_clip((1. + -20 * log10(Hmag) / s->mag) * s->h / 2, 0, s->h - 1); | |
152 | ✗ | x = lrint(f); | |
153 | ✗ | if (prev_v == -1) | |
154 | ✗ | prev_v = v; | |
155 | ✗ | if (v <= prev_v) { | |
156 | ✗ | for (y = v; y <= prev_v; y++) | |
157 | ✗ | AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg)); | |
158 | } else { | ||
159 | ✗ | for (y = prev_v; y <= v; y++) | |
160 | ✗ | AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg)); | |
161 | } | ||
162 | |||
163 | ✗ | prev_v = v; | |
164 | } | ||
165 | } | ||
166 | |||
167 | ✗ | av_free(colors); | |
168 | } | ||
169 | |||
170 | ✗ | static int config_video(AVFilterLink *outlink) | |
171 | { | ||
172 | ✗ | AVFilterContext *ctx = outlink->src; | |
173 | ✗ | AudioNEqualizerContext *s = ctx->priv; | |
174 | ✗ | AVFilterLink *inlink = ctx->inputs[0]; | |
175 | AVFrame *out; | ||
176 | |||
177 | ✗ | outlink->w = s->w; | |
178 | ✗ | outlink->h = s->h; | |
179 | |||
180 | ✗ | av_frame_free(&s->video); | |
181 | ✗ | s->video = out = ff_get_video_buffer(outlink, outlink->w, outlink->h); | |
182 | ✗ | if (!out) | |
183 | ✗ | return AVERROR(ENOMEM); | |
184 | ✗ | outlink->sample_aspect_ratio = (AVRational){1,1}; | |
185 | |||
186 | ✗ | draw_curves(ctx, inlink, out); | |
187 | |||
188 | ✗ | return 0; | |
189 | } | ||
190 | |||
191 | 2 | static av_cold int init(AVFilterContext *ctx) | |
192 | { | ||
193 | 2 | AudioNEqualizerContext *s = ctx->priv; | |
194 | AVFilterPad pad, vpad; | ||
195 | int ret; | ||
196 | |||
197 | 2 | pad = (AVFilterPad){ | |
198 | .name = "out0", | ||
199 | .type = AVMEDIA_TYPE_AUDIO, | ||
200 | }; | ||
201 | |||
202 | 2 | ret = ff_append_outpad(ctx, &pad); | |
203 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret < 0) |
204 | ✗ | return ret; | |
205 | |||
206 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (s->draw_curves) { |
207 | ✗ | vpad = (AVFilterPad){ | |
208 | .name = "out1", | ||
209 | .type = AVMEDIA_TYPE_VIDEO, | ||
210 | .config_props = config_video, | ||
211 | }; | ||
212 | ✗ | ret = ff_append_outpad(ctx, &vpad); | |
213 | ✗ | if (ret < 0) | |
214 | ✗ | return ret; | |
215 | } | ||
216 | |||
217 | 2 | return 0; | |
218 | } | ||
219 | |||
220 | 1 | static int query_formats(AVFilterContext *ctx) | |
221 | { | ||
222 | 1 | AVFilterLink *inlink = ctx->inputs[0]; | |
223 | 1 | AVFilterLink *outlink = ctx->outputs[0]; | |
224 | 1 | AudioNEqualizerContext *s = ctx->priv; | |
225 | AVFilterFormats *formats; | ||
226 | AVFilterChannelLayouts *layouts; | ||
227 | static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE }; | ||
228 | static const enum AVSampleFormat sample_fmts[] = { | ||
229 | AV_SAMPLE_FMT_DBLP, | ||
230 | AV_SAMPLE_FMT_NONE | ||
231 | }; | ||
232 | int ret; | ||
233 | |||
234 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (s->draw_curves) { |
235 | ✗ | AVFilterLink *videolink = ctx->outputs[1]; | |
236 | ✗ | formats = ff_make_format_list(pix_fmts); | |
237 | ✗ | if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0) | |
238 | ✗ | return ret; | |
239 | } | ||
240 | |||
241 | 1 | formats = ff_make_format_list(sample_fmts); | |
242 |
2/4✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
|
2 | if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0 || |
243 | 1 | (ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0) | |
244 | ✗ | return ret; | |
245 | |||
246 | 1 | layouts = ff_all_channel_counts(); | |
247 |
2/4✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
|
2 | if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0 || |
248 | 1 | (ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0) | |
249 | ✗ | return ret; | |
250 | |||
251 | 1 | formats = ff_all_samplerates(); | |
252 |
2/4✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
|
2 | if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 || |
253 | 1 | (ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0) | |
254 | ✗ | return ret; | |
255 | |||
256 | 1 | return 0; | |
257 | } | ||
258 | |||
259 | 2 | static av_cold void uninit(AVFilterContext *ctx) | |
260 | { | ||
261 | 2 | AudioNEqualizerContext *s = ctx->priv; | |
262 | |||
263 | 2 | av_frame_free(&s->video); | |
264 | 2 | av_freep(&s->filters); | |
265 | 2 | s->nb_filters = 0; | |
266 | 2 | s->nb_allocated = 0; | |
267 | 2 | } | |
268 | |||
269 | ✗ | static void butterworth_fo_section(FoSection *S, double beta, | |
270 | double si, double g, double g0, | ||
271 | double D, double c0) | ||
272 | { | ||
273 | ✗ | if (c0 == 1 || c0 == -1) { | |
274 | ✗ | S->b0 = (g*g*beta*beta + 2*g*g0*si*beta + g0*g0)/D; | |
275 | ✗ | S->b1 = 2*c0*(g*g*beta*beta - g0*g0)/D; | |
276 | ✗ | S->b2 = (g*g*beta*beta - 2*g0*g*beta*si + g0*g0)/D; | |
277 | ✗ | S->b3 = 0; | |
278 | ✗ | S->b4 = 0; | |
279 | |||
280 | ✗ | S->a0 = 1; | |
281 | ✗ | S->a1 = 2*c0*(beta*beta - 1)/D; | |
282 | ✗ | S->a2 = (beta*beta - 2*beta*si + 1)/D; | |
283 | ✗ | S->a3 = 0; | |
284 | ✗ | S->a4 = 0; | |
285 | } else { | ||
286 | ✗ | S->b0 = (g*g*beta*beta + 2*g*g0*si*beta + g0*g0)/D; | |
287 | ✗ | S->b1 = -4*c0*(g0*g0 + g*g0*si*beta)/D; | |
288 | ✗ | S->b2 = 2*(g0*g0*(1 + 2*c0*c0) - g*g*beta*beta)/D; | |
289 | ✗ | S->b3 = -4*c0*(g0*g0 - g*g0*si*beta)/D; | |
290 | ✗ | S->b4 = (g*g*beta*beta - 2*g*g0*si*beta + g0*g0)/D; | |
291 | |||
292 | ✗ | S->a0 = 1; | |
293 | ✗ | S->a1 = -4*c0*(1 + si*beta)/D; | |
294 | ✗ | S->a2 = 2*(1 + 2*c0*c0 - beta*beta)/D; | |
295 | ✗ | S->a3 = -4*c0*(1 - si*beta)/D; | |
296 | ✗ | S->a4 = (beta*beta - 2*si*beta + 1)/D; | |
297 | } | ||
298 | ✗ | } | |
299 | |||
300 | ✗ | static void butterworth_bp_filter(EqualizatorFilter *f, | |
301 | int N, double w0, double wb, | ||
302 | double G, double Gb, double G0) | ||
303 | { | ||
304 | double g, c0, g0, beta; | ||
305 | double epsilon; | ||
306 | ✗ | int r = N % 2; | |
307 | ✗ | int L = (N - r) / 2; | |
308 | int i; | ||
309 | |||
310 | ✗ | if (G == 0 && G0 == 0) { | |
311 | ✗ | f->section[0].a0 = 1; | |
312 | ✗ | f->section[0].b0 = 1; | |
313 | ✗ | f->section[1].a0 = 1; | |
314 | ✗ | f->section[1].b0 = 1; | |
315 | ✗ | return; | |
316 | } | ||
317 | |||
318 | ✗ | G = ff_exp10(G/20); | |
319 | ✗ | Gb = ff_exp10(Gb/20); | |
320 | ✗ | G0 = ff_exp10(G0/20); | |
321 | |||
322 | ✗ | epsilon = sqrt((G * G - Gb * Gb) / (Gb * Gb - G0 * G0)); | |
323 | ✗ | g = pow(G, 1.0 / N); | |
324 | ✗ | g0 = pow(G0, 1.0 / N); | |
325 | ✗ | beta = pow(epsilon, -1.0 / N) * tan(wb/2); | |
326 | ✗ | c0 = cos(w0); | |
327 | |||
328 | ✗ | for (i = 1; i <= L; i++) { | |
329 | ✗ | double ui = (2.0 * i - 1) / N; | |
330 | ✗ | double si = sin(M_PI * ui / 2.0); | |
331 | ✗ | double Di = beta * beta + 2 * si * beta + 1; | |
332 | |||
333 | ✗ | butterworth_fo_section(&f->section[i - 1], beta, si, g, g0, Di, c0); | |
334 | } | ||
335 | } | ||
336 | |||
337 | 2 | static void chebyshev1_fo_section(FoSection *S, double a, | |
338 | double c, double tetta_b, | ||
339 | double g0, double si, double b, | ||
340 | double D, double c0) | ||
341 | { | ||
342 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
2 | if (c0 == 1 || c0 == -1) { |
343 | ✗ | S->b0 = (tetta_b*tetta_b*(b*b+g0*g0*c*c) + 2*g0*b*si*tetta_b*tetta_b + g0*g0)/D; | |
344 | ✗ | S->b1 = 2*c0*(tetta_b*tetta_b*(b*b+g0*g0*c*c) - g0*g0)/D; | |
345 | ✗ | S->b2 = (tetta_b*tetta_b*(b*b+g0*g0*c*c) - 2*g0*b*si*tetta_b + g0*g0)/D; | |
346 | ✗ | S->b3 = 0; | |
347 | ✗ | S->b4 = 0; | |
348 | |||
349 | ✗ | S->a0 = 1; | |
350 | ✗ | S->a1 = 2*c0*(tetta_b*tetta_b*(a*a+c*c) - 1)/D; | |
351 | ✗ | S->a2 = (tetta_b*tetta_b*(a*a+c*c) - 2*a*si*tetta_b + 1)/D; | |
352 | ✗ | S->a3 = 0; | |
353 | ✗ | S->a4 = 0; | |
354 | } else { | ||
355 | 2 | S->b0 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b + 2*g0*b*si*tetta_b + g0*g0)/D; | |
356 | 2 | S->b1 = -4*c0*(g0*g0 + g0*b*si*tetta_b)/D; | |
357 | 2 | S->b2 = 2*(g0*g0*(1 + 2*c0*c0) - (b*b + g0*g0*c*c)*tetta_b*tetta_b)/D; | |
358 | 2 | S->b3 = -4*c0*(g0*g0 - g0*b*si*tetta_b)/D; | |
359 | 2 | S->b4 = ((b*b + g0*g0*c*c)*tetta_b*tetta_b - 2*g0*b*si*tetta_b + g0*g0)/D; | |
360 | |||
361 | 2 | S->a0 = 1; | |
362 | 2 | S->a1 = -4*c0*(1 + a*si*tetta_b)/D; | |
363 | 2 | S->a2 = 2*(1 + 2*c0*c0 - (a*a + c*c)*tetta_b*tetta_b)/D; | |
364 | 2 | S->a3 = -4*c0*(1 - a*si*tetta_b)/D; | |
365 | 2 | S->a4 = ((a*a + c*c)*tetta_b*tetta_b - 2*a*si*tetta_b + 1)/D; | |
366 | } | ||
367 | 2 | } | |
368 | |||
369 | 1 | static void chebyshev1_bp_filter(EqualizatorFilter *f, | |
370 | int N, double w0, double wb, | ||
371 | double G, double Gb, double G0) | ||
372 | { | ||
373 | double a, b, c0, g0, alfa, beta, tetta_b; | ||
374 | double epsilon; | ||
375 | 1 | int r = N % 2; | |
376 | 1 | int L = (N - r) / 2; | |
377 | int i; | ||
378 | |||
379 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1 | if (G == 0 && G0 == 0) { |
380 | ✗ | f->section[0].a0 = 1; | |
381 | ✗ | f->section[0].b0 = 1; | |
382 | ✗ | f->section[1].a0 = 1; | |
383 | ✗ | f->section[1].b0 = 1; | |
384 | ✗ | return; | |
385 | } | ||
386 | |||
387 | 1 | G = ff_exp10(G/20); | |
388 | 1 | Gb = ff_exp10(Gb/20); | |
389 | 1 | G0 = ff_exp10(G0/20); | |
390 | |||
391 | 1 | epsilon = sqrt((G*G - Gb*Gb) / (Gb*Gb - G0*G0)); | |
392 | 1 | g0 = pow(G0,1.0/N); | |
393 | 1 | alfa = pow(1.0/epsilon + sqrt(1 + 1/(epsilon*epsilon)), 1.0/N); | |
394 | 1 | beta = pow(G/epsilon + Gb * sqrt(1 + 1/(epsilon*epsilon)), 1.0/N); | |
395 | 1 | a = 0.5 * (alfa - 1.0/alfa); | |
396 | 1 | b = 0.5 * (beta - g0*g0*(1/beta)); | |
397 | 1 | tetta_b = tan(wb/2); | |
398 | 1 | c0 = cos(w0); | |
399 | |||
400 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
|
3 | for (i = 1; i <= L; i++) { |
401 | 2 | double ui = (2.0*i-1.0)/N; | |
402 | 2 | double ci = cos(M_PI*ui/2.0); | |
403 | 2 | double si = sin(M_PI*ui/2.0); | |
404 | 2 | double Di = (a*a + ci*ci)*tetta_b*tetta_b + 2.0*a*si*tetta_b + 1; | |
405 | |||
406 | 2 | chebyshev1_fo_section(&f->section[i - 1], a, ci, tetta_b, g0, si, b, Di, c0); | |
407 | } | ||
408 | } | ||
409 | |||
410 | ✗ | static void chebyshev2_fo_section(FoSection *S, double a, | |
411 | double c, double tetta_b, | ||
412 | double g, double si, double b, | ||
413 | double D, double c0) | ||
414 | { | ||
415 | ✗ | if (c0 == 1 || c0 == -1) { | |
416 | ✗ | S->b0 = (g*g*tetta_b*tetta_b + 2*tetta_b*g*b*si + b*b + g*g*c*c)/D; | |
417 | ✗ | S->b1 = 2*c0*(g*g*tetta_b*tetta_b - b*b - g*g*c*c)/D; | |
418 | ✗ | S->b2 = (g*g*tetta_b*tetta_b - 2*tetta_b*g*b*si + b*b + g*g*c*c)/D; | |
419 | ✗ | S->b3 = 0; | |
420 | ✗ | S->b4 = 0; | |
421 | |||
422 | ✗ | S->a0 = 1; | |
423 | ✗ | S->a1 = 2*c0*(tetta_b*tetta_b - a*a - c*c)/D; | |
424 | ✗ | S->a2 = (tetta_b*tetta_b - 2*tetta_b*a*si + a*a + c*c)/D; | |
425 | ✗ | S->a3 = 0; | |
426 | ✗ | S->a4 = 0; | |
427 | } else { | ||
428 | ✗ | S->b0 = (g*g*tetta_b*tetta_b + 2*g*b*si*tetta_b + b*b + g*g*c*c)/D; | |
429 | ✗ | S->b1 = -4*c0*(b*b + g*g*c*c + g*b*si*tetta_b)/D; | |
430 | ✗ | S->b2 = 2*((b*b + g*g*c*c)*(1 + 2*c0*c0) - g*g*tetta_b*tetta_b)/D; | |
431 | ✗ | S->b3 = -4*c0*(b*b + g*g*c*c - g*b*si*tetta_b)/D; | |
432 | ✗ | S->b4 = (g*g*tetta_b*tetta_b - 2*g*b*si*tetta_b + b*b + g*g*c*c)/D; | |
433 | |||
434 | ✗ | S->a0 = 1; | |
435 | ✗ | S->a1 = -4*c0*(a*a + c*c + a*si*tetta_b)/D; | |
436 | ✗ | S->a2 = 2*((a*a + c*c)*(1 + 2*c0*c0) - tetta_b*tetta_b)/D; | |
437 | ✗ | S->a3 = -4*c0*(a*a + c*c - a*si*tetta_b)/D; | |
438 | ✗ | S->a4 = (tetta_b*tetta_b - 2*a*si*tetta_b + a*a + c*c)/D; | |
439 | } | ||
440 | ✗ | } | |
441 | |||
442 | ✗ | static void chebyshev2_bp_filter(EqualizatorFilter *f, | |
443 | int N, double w0, double wb, | ||
444 | double G, double Gb, double G0) | ||
445 | { | ||
446 | double a, b, c0, tetta_b; | ||
447 | double epsilon, g, eu, ew; | ||
448 | ✗ | int r = N % 2; | |
449 | ✗ | int L = (N - r) / 2; | |
450 | int i; | ||
451 | |||
452 | ✗ | if (G == 0 && G0 == 0) { | |
453 | ✗ | f->section[0].a0 = 1; | |
454 | ✗ | f->section[0].b0 = 1; | |
455 | ✗ | f->section[1].a0 = 1; | |
456 | ✗ | f->section[1].b0 = 1; | |
457 | ✗ | return; | |
458 | } | ||
459 | |||
460 | ✗ | G = ff_exp10(G/20); | |
461 | ✗ | Gb = ff_exp10(Gb/20); | |
462 | ✗ | G0 = ff_exp10(G0/20); | |
463 | |||
464 | ✗ | epsilon = sqrt((G*G - Gb*Gb) / (Gb*Gb - G0*G0)); | |
465 | ✗ | g = pow(G, 1.0 / N); | |
466 | ✗ | eu = pow(epsilon + sqrt(1 + epsilon*epsilon), 1.0/N); | |
467 | ✗ | ew = pow(G0*epsilon + Gb*sqrt(1 + epsilon*epsilon), 1.0/N); | |
468 | ✗ | a = (eu - 1.0/eu)/2.0; | |
469 | ✗ | b = (ew - g*g/ew)/2.0; | |
470 | ✗ | tetta_b = tan(wb/2); | |
471 | ✗ | c0 = cos(w0); | |
472 | |||
473 | ✗ | for (i = 1; i <= L; i++) { | |
474 | ✗ | double ui = (2.0 * i - 1.0)/N; | |
475 | ✗ | double ci = cos(M_PI * ui / 2.0); | |
476 | ✗ | double si = sin(M_PI * ui / 2.0); | |
477 | ✗ | double Di = tetta_b*tetta_b + 2*a*si*tetta_b + a*a + ci*ci; | |
478 | |||
479 | ✗ | chebyshev2_fo_section(&f->section[i - 1], a, ci, tetta_b, g, si, b, Di, c0); | |
480 | } | ||
481 | } | ||
482 | |||
483 | ✗ | static double butterworth_compute_bw_gain_db(double gain) | |
484 | { | ||
485 | ✗ | double bw_gain = 0; | |
486 | |||
487 | ✗ | if (gain <= -6) | |
488 | ✗ | bw_gain = gain + 3; | |
489 | ✗ | else if(gain > -6 && gain < 6) | |
490 | ✗ | bw_gain = gain * 0.5; | |
491 | ✗ | else if(gain >= 6) | |
492 | ✗ | bw_gain = gain - 3; | |
493 | |||
494 | ✗ | return bw_gain; | |
495 | } | ||
496 | |||
497 | 1 | static double chebyshev1_compute_bw_gain_db(double gain) | |
498 | { | ||
499 | 1 | double bw_gain = 0; | |
500 | |||
501 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (gain <= -6) |
502 | 1 | bw_gain = gain + 1; | |
503 | ✗ | else if(gain > -6 && gain < 6) | |
504 | ✗ | bw_gain = gain * 0.9; | |
505 | ✗ | else if(gain >= 6) | |
506 | ✗ | bw_gain = gain - 1; | |
507 | |||
508 | 1 | return bw_gain; | |
509 | } | ||
510 | |||
511 | ✗ | static double chebyshev2_compute_bw_gain_db(double gain) | |
512 | { | ||
513 | ✗ | double bw_gain = 0; | |
514 | |||
515 | ✗ | if (gain <= -6) | |
516 | ✗ | bw_gain = -3; | |
517 | ✗ | else if(gain > -6 && gain < 6) | |
518 | ✗ | bw_gain = gain * 0.3; | |
519 | ✗ | else if(gain >= 6) | |
520 | ✗ | bw_gain = 3; | |
521 | |||
522 | ✗ | return bw_gain; | |
523 | } | ||
524 | |||
525 | 2 | static inline double hz_2_rad(double x, double fs) | |
526 | { | ||
527 | 2 | return 2 * M_PI * x / fs; | |
528 | } | ||
529 | |||
530 | 1 | static void equalizer(EqualizatorFilter *f, double sample_rate) | |
531 | { | ||
532 | 1 | double w0 = hz_2_rad(f->freq, sample_rate); | |
533 | 1 | double wb = hz_2_rad(f->width, sample_rate); | |
534 | double bw_gain; | ||
535 | |||
536 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1 | switch (f->type) { |
537 | ✗ | case BUTTERWORTH: | |
538 | ✗ | bw_gain = butterworth_compute_bw_gain_db(f->gain); | |
539 | ✗ | butterworth_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0); | |
540 | ✗ | break; | |
541 | 1 | case CHEBYSHEV1: | |
542 | 1 | bw_gain = chebyshev1_compute_bw_gain_db(f->gain); | |
543 | 1 | chebyshev1_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0); | |
544 | 1 | break; | |
545 | ✗ | case CHEBYSHEV2: | |
546 | ✗ | bw_gain = chebyshev2_compute_bw_gain_db(f->gain); | |
547 | ✗ | chebyshev2_bp_filter(f, FILTER_ORDER, w0, wb, f->gain, bw_gain, 0); | |
548 | ✗ | break; | |
549 | } | ||
550 | |||
551 | 1 | } | |
552 | |||
553 | 1 | static int add_filter(AudioNEqualizerContext *s, AVFilterLink *inlink) | |
554 | { | ||
555 | 1 | equalizer(&s->filters[s->nb_filters], inlink->sample_rate); | |
556 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (s->nb_filters >= s->nb_allocated - 1) { |
557 | EqualizatorFilter *filters; | ||
558 | |||
559 | ✗ | filters = av_calloc(s->nb_allocated, 2 * sizeof(*s->filters)); | |
560 | ✗ | if (!filters) | |
561 | ✗ | return AVERROR(ENOMEM); | |
562 | ✗ | memcpy(filters, s->filters, sizeof(*s->filters) * s->nb_allocated); | |
563 | ✗ | av_free(s->filters); | |
564 | ✗ | s->filters = filters; | |
565 | ✗ | s->nb_allocated *= 2; | |
566 | } | ||
567 | 1 | s->nb_filters++; | |
568 | |||
569 | 1 | return 0; | |
570 | } | ||
571 | |||
572 | 1 | static int config_input(AVFilterLink *inlink) | |
573 | { | ||
574 | 1 | AVFilterContext *ctx = inlink->dst; | |
575 | 1 | AudioNEqualizerContext *s = ctx->priv; | |
576 | 1 | char *args = av_strdup(s->args); | |
577 | 1 | char *saveptr = NULL; | |
578 | 1 | int ret = 0; | |
579 | |||
580 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!args) |
581 | ✗ | return AVERROR(ENOMEM); | |
582 | |||
583 | 1 | s->nb_allocated = 32 * inlink->ch_layout.nb_channels; | |
584 | 1 | s->filters = av_calloc(inlink->ch_layout.nb_channels, 32 * sizeof(*s->filters)); | |
585 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!s->filters) { |
586 | ✗ | s->nb_allocated = 0; | |
587 | ✗ | av_free(args); | |
588 | ✗ | return AVERROR(ENOMEM); | |
589 | } | ||
590 | |||
591 | 1 | while (1) { | |
592 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | char *arg = av_strtok(s->nb_filters == 0 ? args : NULL, "|", &saveptr); |
593 | |||
594 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | if (!arg) |
595 | 1 | break; | |
596 | |||
597 | 1 | s->filters[s->nb_filters].type = 0; | |
598 | 1 | if (sscanf(arg, "c%d f=%lf w=%lf g=%lf t=%d", &s->filters[s->nb_filters].channel, | |
599 | 1 | &s->filters[s->nb_filters].freq, | |
600 | 1 | &s->filters[s->nb_filters].width, | |
601 | 1 | &s->filters[s->nb_filters].gain, | |
602 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | &s->filters[s->nb_filters].type) != 5 && |
603 | ✗ | sscanf(arg, "c%d f=%lf w=%lf g=%lf", &s->filters[s->nb_filters].channel, | |
604 | ✗ | &s->filters[s->nb_filters].freq, | |
605 | ✗ | &s->filters[s->nb_filters].width, | |
606 | ✗ | &s->filters[s->nb_filters].gain) != 4 ) { | |
607 | ✗ | av_free(args); | |
608 | ✗ | return AVERROR(EINVAL); | |
609 | } | ||
610 | |||
611 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (s->filters[s->nb_filters].freq < 0 || |
612 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | s->filters[s->nb_filters].freq > inlink->sample_rate / 2.0) |
613 | ✗ | s->filters[s->nb_filters].ignore = 1; | |
614 | |||
615 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (s->filters[s->nb_filters].channel < 0 || |
616 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | s->filters[s->nb_filters].channel >= inlink->ch_layout.nb_channels) |
617 | ✗ | s->filters[s->nb_filters].ignore = 1; | |
618 | |||
619 | 1 | s->filters[s->nb_filters].type = av_clip(s->filters[s->nb_filters].type, 0, NB_TYPES - 1); | |
620 | 1 | ret = add_filter(s, inlink); | |
621 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (ret < 0) |
622 | ✗ | break; | |
623 | } | ||
624 | |||
625 | 1 | av_free(args); | |
626 | |||
627 | 1 | return ret; | |
628 | } | ||
629 | |||
630 | ✗ | static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, | |
631 | char *res, int res_len, int flags) | ||
632 | { | ||
633 | ✗ | AudioNEqualizerContext *s = ctx->priv; | |
634 | ✗ | AVFilterLink *inlink = ctx->inputs[0]; | |
635 | ✗ | int ret = AVERROR(ENOSYS); | |
636 | |||
637 | ✗ | if (!strcmp(cmd, "change")) { | |
638 | double freq, width, gain; | ||
639 | int filter; | ||
640 | |||
641 | ✗ | if (sscanf(args, "%d|f=%lf|w=%lf|g=%lf", &filter, &freq, &width, &gain) != 4) | |
642 | ✗ | return AVERROR(EINVAL); | |
643 | |||
644 | ✗ | if (filter < 0 || filter >= s->nb_filters) | |
645 | ✗ | return AVERROR(EINVAL); | |
646 | |||
647 | ✗ | if (freq < 0 || freq > inlink->sample_rate / 2.0) | |
648 | ✗ | return AVERROR(EINVAL); | |
649 | |||
650 | ✗ | s->filters[filter].freq = freq; | |
651 | ✗ | s->filters[filter].width = width; | |
652 | ✗ | s->filters[filter].gain = gain; | |
653 | ✗ | equalizer(&s->filters[filter], inlink->sample_rate); | |
654 | ✗ | if (s->draw_curves) | |
655 | ✗ | draw_curves(ctx, inlink, s->video); | |
656 | |||
657 | ✗ | ret = 0; | |
658 | } | ||
659 | |||
660 | ✗ | return ret; | |
661 | } | ||
662 | |||
663 | 529200 | static inline double section_process(FoSection *S, double in) | |
664 | { | ||
665 | double out; | ||
666 | |||
667 | 529200 | out = S->b0 * in; | |
668 | 529200 | out+= S->b1 * S->num[0] - S->denum[0] * S->a1; | |
669 | 529200 | out+= S->b2 * S->num[1] - S->denum[1] * S->a2; | |
670 | 529200 | out+= S->b3 * S->num[2] - S->denum[2] * S->a3; | |
671 | 529200 | out+= S->b4 * S->num[3] - S->denum[3] * S->a4; | |
672 | |||
673 | 529200 | S->num[3] = S->num[2]; | |
674 | 529200 | S->num[2] = S->num[1]; | |
675 | 529200 | S->num[1] = S->num[0]; | |
676 | 529200 | S->num[0] = in; | |
677 | |||
678 | 529200 | S->denum[3] = S->denum[2]; | |
679 | 529200 | S->denum[2] = S->denum[1]; | |
680 | 529200 | S->denum[1] = S->denum[0]; | |
681 | 529200 | S->denum[0] = out; | |
682 | |||
683 | 529200 | return out; | |
684 | } | ||
685 | |||
686 | 264600 | static double process_sample(FoSection *s1, double in) | |
687 | { | ||
688 | 264600 | double p0 = in, p1; | |
689 | int i; | ||
690 | |||
691 |
2/2✓ Branch 0 taken 529200 times.
✓ Branch 1 taken 264600 times.
|
793800 | for (i = 0; i < FILTER_ORDER / 2; i++) { |
692 | 529200 | p1 = section_process(&s1[i], p0); | |
693 | 529200 | p0 = p1; | |
694 | } | ||
695 | |||
696 | 264600 | return p1; | |
697 | } | ||
698 | |||
699 | 130 | static int filter_channels(AVFilterContext *ctx, void *arg, | |
700 | int jobnr, int nb_jobs) | ||
701 | { | ||
702 | 130 | AudioNEqualizerContext *s = ctx->priv; | |
703 | 130 | AVFrame *buf = arg; | |
704 | 130 | const int start = (buf->ch_layout.nb_channels * jobnr) / nb_jobs; | |
705 | 130 | const int end = (buf->ch_layout.nb_channels * (jobnr+1)) / nb_jobs; | |
706 | |||
707 |
2/2✓ Branch 0 taken 130 times.
✓ Branch 1 taken 130 times.
|
260 | for (int i = 0; i < s->nb_filters; i++) { |
708 | 130 | EqualizatorFilter *f = &s->filters[i]; | |
709 | double *bptr; | ||
710 | |||
711 |
2/4✓ Branch 0 taken 130 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 130 times.
|
130 | if (f->gain == 0. || f->ignore) |
712 | ✗ | continue; | |
713 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 65 times.
|
130 | if (f->channel < start || |
714 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | f->channel >= end) |
715 | 65 | continue; | |
716 | |||
717 | 65 | bptr = (double *)buf->extended_data[f->channel]; | |
718 |
2/2✓ Branch 0 taken 264600 times.
✓ Branch 1 taken 65 times.
|
264665 | for (int n = 0; n < buf->nb_samples; n++) { |
719 | 264600 | double sample = bptr[n]; | |
720 | |||
721 | 264600 | sample = process_sample(f->section, sample); | |
722 | 264600 | bptr[n] = sample; | |
723 | } | ||
724 | } | ||
725 | |||
726 | 130 | return 0; | |
727 | } | ||
728 | |||
729 | 65 | static int filter_frame(AVFilterLink *inlink, AVFrame *buf) | |
730 | { | ||
731 | 65 | AVFilterContext *ctx = inlink->dst; | |
732 | 65 | AudioNEqualizerContext *s = ctx->priv; | |
733 | 65 | AVFilterLink *outlink = ctx->outputs[0]; | |
734 | |||
735 |
1/2✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
|
65 | if (!ctx->is_disabled) |
736 | 65 | ff_filter_execute(ctx, filter_channels, buf, NULL, | |
737 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | FFMIN(inlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx))); |
738 | |||
739 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.
|
65 | if (s->draw_curves) { |
740 | AVFrame *clone; | ||
741 | |||
742 | ✗ | const int64_t pts = buf->pts + | |
743 | ✗ | av_rescale_q(buf->nb_samples, (AVRational){ 1, inlink->sample_rate }, | |
744 | outlink->time_base); | ||
745 | int ret; | ||
746 | |||
747 | ✗ | s->video->pts = pts; | |
748 | ✗ | clone = av_frame_clone(s->video); | |
749 | ✗ | if (!clone) | |
750 | ✗ | return AVERROR(ENOMEM); | |
751 | ✗ | ret = ff_filter_frame(ctx->outputs[1], clone); | |
752 | ✗ | if (ret < 0) | |
753 | ✗ | return ret; | |
754 | } | ||
755 | |||
756 | 65 | return ff_filter_frame(outlink, buf); | |
757 | } | ||
758 | |||
759 | static const AVFilterPad inputs[] = { | ||
760 | { | ||
761 | .name = "default", | ||
762 | .type = AVMEDIA_TYPE_AUDIO, | ||
763 | .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE, | ||
764 | .config_props = config_input, | ||
765 | .filter_frame = filter_frame, | ||
766 | }, | ||
767 | }; | ||
768 | |||
769 | const AVFilter ff_af_anequalizer = { | ||
770 | .name = "anequalizer", | ||
771 | .description = NULL_IF_CONFIG_SMALL("Apply high-order audio parametric multi band equalizer."), | ||
772 | .priv_size = sizeof(AudioNEqualizerContext), | ||
773 | .priv_class = &anequalizer_class, | ||
774 | .init = init, | ||
775 | .uninit = uninit, | ||
776 | FILTER_INPUTS(inputs), | ||
777 | .outputs = NULL, | ||
778 | FILTER_QUERY_FUNC(query_formats), | ||
779 | .process_command = process_command, | ||
780 | .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS | | ||
781 | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | | ||
782 | AVFILTER_FLAG_SLICE_THREADS, | ||
783 | }; | ||
784 |