| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * Copyright (c) 2001-2010 Krzysztof Foltman, Markus Schmidt, Thor Harald Johansen, Damien Zammit and others | ||
| 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 | ||
| 8 | * License 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 GNU | ||
| 14 | * Lesser General Public License for more details. | ||
| 15 | * | ||
| 16 | * You should have received a copy of the GNU Lesser General Public | ||
| 17 | * License along with FFmpeg; if not, write to the Free Software | ||
| 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 19 | */ | ||
| 20 | |||
| 21 | #include "libavutil/opt.h" | ||
| 22 | #include "avfilter.h" | ||
| 23 | #include "internal.h" | ||
| 24 | #include "audio.h" | ||
| 25 | |||
| 26 | typedef struct BiquadCoeffs { | ||
| 27 | double a0, a1, a2, b1, b2; | ||
| 28 | } BiquadCoeffs; | ||
| 29 | |||
| 30 | typedef struct RIAACurve { | ||
| 31 | BiquadCoeffs r1; | ||
| 32 | BiquadCoeffs brickw; | ||
| 33 | int use_brickw; | ||
| 34 | } RIAACurve; | ||
| 35 | |||
| 36 | typedef struct AudioEmphasisContext { | ||
| 37 | const AVClass *class; | ||
| 38 | int mode, type; | ||
| 39 | double level_in, level_out; | ||
| 40 | |||
| 41 | RIAACurve rc; | ||
| 42 | |||
| 43 | AVFrame *w; | ||
| 44 | } AudioEmphasisContext; | ||
| 45 | |||
| 46 | #define OFFSET(x) offsetof(AudioEmphasisContext, x) | ||
| 47 | #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM | ||
| 48 | |||
| 49 | static const AVOption aemphasis_options[] = { | ||
| 50 | { "level_in", "set input gain", OFFSET(level_in), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 64, FLAGS }, | ||
| 51 | { "level_out", "set output gain", OFFSET(level_out), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 64, FLAGS }, | ||
| 52 | { "mode", "set filter mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "mode" }, | ||
| 53 | { "reproduction", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "mode" }, | ||
| 54 | { "production", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "mode" }, | ||
| 55 | { "type", "set filter type", OFFSET(type), AV_OPT_TYPE_INT, {.i64=4}, 0, 8, FLAGS, .unit = "type" }, | ||
| 56 | { "col", "Columbia", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "type" }, | ||
| 57 | { "emi", "EMI", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "type" }, | ||
| 58 | { "bsi", "BSI (78RPM)", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, .unit = "type" }, | ||
| 59 | { "riaa", "RIAA", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, FLAGS, .unit = "type" }, | ||
| 60 | { "cd", "Compact Disc (CD)", 0, AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, FLAGS, .unit = "type" }, | ||
| 61 | { "50fm", "50µs (FM)", 0, AV_OPT_TYPE_CONST, {.i64=5}, 0, 0, FLAGS, .unit = "type" }, | ||
| 62 | { "75fm", "75µs (FM)", 0, AV_OPT_TYPE_CONST, {.i64=6}, 0, 0, FLAGS, .unit = "type" }, | ||
| 63 | { "50kf", "50µs (FM-KF)", 0, AV_OPT_TYPE_CONST, {.i64=7}, 0, 0, FLAGS, .unit = "type" }, | ||
| 64 | { "75kf", "75µs (FM-KF)", 0, AV_OPT_TYPE_CONST, {.i64=8}, 0, 0, FLAGS, .unit = "type" }, | ||
| 65 | { NULL } | ||
| 66 | }; | ||
| 67 | |||
| 68 | AVFILTER_DEFINE_CLASS(aemphasis); | ||
| 69 | |||
| 70 | 390 | static inline void biquad_process(BiquadCoeffs *bq, double *dst, const double *src, int nb_samples, | |
| 71 | double *w, double level_in, double level_out) | ||
| 72 | { | ||
| 73 | 390 | const double a0 = bq->a0; | |
| 74 | 390 | const double a1 = bq->a1; | |
| 75 | 390 | const double a2 = bq->a2; | |
| 76 | 390 | const double b1 = bq->b1; | |
| 77 | 390 | const double b2 = bq->b2; | |
| 78 | 390 | double w1 = w[0]; | |
| 79 | 390 | double w2 = w[1]; | |
| 80 | |||
| 81 |
2/2✓ Branch 0 taken 1587600 times.
✓ Branch 1 taken 390 times.
|
1587990 | for (int i = 0; i < nb_samples; i++) { |
| 82 | 1587600 | double n = src[i] * level_in; | |
| 83 | 1587600 | double tmp = n - w1 * b1 - w2 * b2; | |
| 84 | 1587600 | double out = tmp * a0 + w1 * a1 + w2 * a2; | |
| 85 | |||
| 86 | 1587600 | w2 = w1; | |
| 87 | 1587600 | w1 = tmp; | |
| 88 | |||
| 89 | 1587600 | dst[i] = out * level_out; | |
| 90 | } | ||
| 91 | |||
| 92 | 390 | w[0] = w1; | |
| 93 | 390 | w[1] = w2; | |
| 94 | 390 | } | |
| 95 | |||
| 96 | typedef struct ThreadData { | ||
| 97 | AVFrame *in, *out; | ||
| 98 | } ThreadData; | ||
| 99 | |||
| 100 | 260 | static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) | |
| 101 | { | ||
| 102 | 260 | AudioEmphasisContext *s = ctx->priv; | |
| 103 | 260 | const double level_out = s->level_out; | |
| 104 | 260 | const double level_in = s->level_in; | |
| 105 | 260 | ThreadData *td = arg; | |
| 106 | 260 | AVFrame *out = td->out; | |
| 107 | 260 | AVFrame *in = td->in; | |
| 108 | 260 | const int start = (in->ch_layout.nb_channels * jobnr) / nb_jobs; | |
| 109 | 260 | const int end = (in->ch_layout.nb_channels * (jobnr+1)) / nb_jobs; | |
| 110 | |||
| 111 |
2/2✓ Branch 0 taken 260 times.
✓ Branch 1 taken 260 times.
|
520 | for (int ch = start; ch < end; ch++) { |
| 112 | 260 | const double *src = (const double *)in->extended_data[ch]; | |
| 113 | 260 | double *w = (double *)s->w->extended_data[ch]; | |
| 114 | 260 | double *dst = (double *)out->extended_data[ch]; | |
| 115 | |||
| 116 |
2/2✓ Branch 0 taken 130 times.
✓ Branch 1 taken 130 times.
|
260 | if (s->rc.use_brickw) { |
| 117 | 130 | biquad_process(&s->rc.brickw, dst, src, in->nb_samples, w + 2, level_in, 1.); | |
| 118 | 130 | biquad_process(&s->rc.r1, dst, dst, in->nb_samples, w, 1., level_out); | |
| 119 | } else { | ||
| 120 | 130 | biquad_process(&s->rc.r1, dst, src, in->nb_samples, w, level_in, level_out); | |
| 121 | } | ||
| 122 | } | ||
| 123 | |||
| 124 | 260 | return 0; | |
| 125 | } | ||
| 126 | |||
| 127 | 130 | static int filter_frame(AVFilterLink *inlink, AVFrame *in) | |
| 128 | { | ||
| 129 | 130 | AVFilterContext *ctx = inlink->dst; | |
| 130 | 130 | AVFilterLink *outlink = ctx->outputs[0]; | |
| 131 | ThreadData td; | ||
| 132 | AVFrame *out; | ||
| 133 | |||
| 134 |
1/2✓ Branch 1 taken 130 times.
✗ Branch 2 not taken.
|
130 | if (av_frame_is_writable(in)) { |
| 135 | 130 | out = in; | |
| 136 | } else { | ||
| 137 | ✗ | out = ff_get_audio_buffer(outlink, in->nb_samples); | |
| 138 | ✗ | if (!out) { | |
| 139 | ✗ | av_frame_free(&in); | |
| 140 | ✗ | return AVERROR(ENOMEM); | |
| 141 | } | ||
| 142 | ✗ | av_frame_copy_props(out, in); | |
| 143 | } | ||
| 144 | |||
| 145 | 130 | td.in = in; td.out = out; | |
| 146 | 130 | ff_filter_execute(ctx, filter_channels, &td, NULL, | |
| 147 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 130 times.
|
130 | FFMIN(inlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx))); |
| 148 | |||
| 149 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 130 times.
|
130 | if (in != out) |
| 150 | ✗ | av_frame_free(&in); | |
| 151 | 130 | return ff_filter_frame(outlink, out); | |
| 152 | } | ||
| 153 | |||
| 154 | 1 | static inline void set_highshelf_rbj(BiquadCoeffs *bq, double freq, double q, double peak, double sr) | |
| 155 | { | ||
| 156 | 1 | double A = sqrt(peak); | |
| 157 | 1 | double w0 = freq * 2 * M_PI / sr; | |
| 158 | 1 | double alpha = sin(w0) / (2 * q); | |
| 159 | 1 | double cw0 = cos(w0); | |
| 160 | 1 | double tmp = 2 * sqrt(A) * alpha; | |
| 161 | 1 | double b0 = 0, ib0 = 0; | |
| 162 | |||
| 163 | 1 | bq->a0 = A*( (A+1) + (A-1)*cw0 + tmp); | |
| 164 | 1 | bq->a1 = -2*A*( (A-1) + (A+1)*cw0); | |
| 165 | 1 | bq->a2 = A*( (A+1) + (A-1)*cw0 - tmp); | |
| 166 | 1 | b0 = (A+1) - (A-1)*cw0 + tmp; | |
| 167 | 1 | bq->b1 = 2*( (A-1) - (A+1)*cw0); | |
| 168 | 1 | bq->b2 = (A+1) - (A-1)*cw0 - tmp; | |
| 169 | |||
| 170 | 1 | ib0 = 1 / b0; | |
| 171 | 1 | bq->b1 *= ib0; | |
| 172 | 1 | bq->b2 *= ib0; | |
| 173 | 1 | bq->a0 *= ib0; | |
| 174 | 1 | bq->a1 *= ib0; | |
| 175 | 1 | bq->a2 *= ib0; | |
| 176 | 1 | } | |
| 177 | |||
| 178 | 2 | static inline void set_lp_rbj(BiquadCoeffs *bq, double fc, double q, double sr, double gain) | |
| 179 | { | ||
| 180 | 2 | double omega = 2.0 * M_PI * fc / sr; | |
| 181 | 2 | double sn = sin(omega); | |
| 182 | 2 | double cs = cos(omega); | |
| 183 | 2 | double alpha = sn/(2 * q); | |
| 184 | 2 | double inv = 1.0/(1.0 + alpha); | |
| 185 | |||
| 186 | 2 | bq->a2 = bq->a0 = gain * inv * (1.0 - cs) * 0.5; | |
| 187 | 2 | bq->a1 = bq->a0 + bq->a0; | |
| 188 | 2 | bq->b1 = (-2.0 * cs * inv); | |
| 189 | 2 | bq->b2 = ((1.0 - alpha) * inv); | |
| 190 | 2 | } | |
| 191 | |||
| 192 | 1 | static double freq_gain(BiquadCoeffs *c, double freq, double sr) | |
| 193 | { | ||
| 194 | double zr, zi; | ||
| 195 | |||
| 196 | 1 | freq *= 2.0 * M_PI / sr; | |
| 197 | 1 | zr = cos(freq); | |
| 198 | 1 | zi = -sin(freq); | |
| 199 | |||
| 200 | /* |(a0 + a1*z + a2*z^2)/(1 + b1*z + b2*z^2)| */ | ||
| 201 | 2 | return hypot(c->a0 + c->a1*zr + c->a2*(zr*zr-zi*zi), c->a1*zi + 2*c->a2*zr*zi) / | |
| 202 | 1 | hypot(1 + c->b1*zr + c->b2*(zr*zr-zi*zi), c->b1*zi + 2*c->b2*zr*zi); | |
| 203 | } | ||
| 204 | |||
| 205 | 2 | static int config_input(AVFilterLink *inlink) | |
| 206 | { | ||
| 207 | double i, j, k, g, t, a0, a1, a2, b1, b2, tau1, tau2, tau3; | ||
| 208 | 2 | double cutfreq, gain1kHz, gc, sr = inlink->sample_rate; | |
| 209 | 2 | AVFilterContext *ctx = inlink->dst; | |
| 210 | 2 | AudioEmphasisContext *s = ctx->priv; | |
| 211 | BiquadCoeffs coeffs; | ||
| 212 | |||
| 213 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (!s->w) |
| 214 | 2 | s->w = ff_get_audio_buffer(inlink, 4); | |
| 215 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!s->w) |
| 216 | ✗ | return AVERROR(ENOMEM); | |
| 217 | |||
| 218 |
2/7✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
|
2 | switch (s->type) { |
| 219 | ✗ | case 0: //"Columbia" | |
| 220 | ✗ | i = 100.; | |
| 221 | ✗ | j = 500.; | |
| 222 | ✗ | k = 1590.; | |
| 223 | ✗ | break; | |
| 224 | ✗ | case 1: //"EMI" | |
| 225 | ✗ | i = 70.; | |
| 226 | ✗ | j = 500.; | |
| 227 | ✗ | k = 2500.; | |
| 228 | ✗ | break; | |
| 229 | ✗ | case 2: //"BSI(78rpm)" | |
| 230 | ✗ | i = 50.; | |
| 231 | ✗ | j = 353.; | |
| 232 | ✗ | k = 3180.; | |
| 233 | ✗ | break; | |
| 234 | 1 | case 3: //"RIAA" | |
| 235 | default: | ||
| 236 | 1 | tau1 = 0.003180; | |
| 237 | 1 | tau2 = 0.000318; | |
| 238 | 1 | tau3 = 0.000075; | |
| 239 | 1 | i = 1. / (2. * M_PI * tau1); | |
| 240 | 1 | j = 1. / (2. * M_PI * tau2); | |
| 241 | 1 | k = 1. / (2. * M_PI * tau3); | |
| 242 | 1 | break; | |
| 243 | ✗ | case 4: //"CD Mastering" | |
| 244 | ✗ | tau1 = 0.000050; | |
| 245 | ✗ | tau2 = 0.000015; | |
| 246 | ✗ | tau3 = 0.0000001;// 1.6MHz out of audible range for null impact | |
| 247 | ✗ | i = 1. / (2. * M_PI * tau1); | |
| 248 | ✗ | j = 1. / (2. * M_PI * tau2); | |
| 249 | ✗ | k = 1. / (2. * M_PI * tau3); | |
| 250 | ✗ | break; | |
| 251 | 1 | case 5: //"50µs FM (Europe)" | |
| 252 | 1 | tau1 = 0.000050; | |
| 253 | 1 | tau2 = tau1 / 20;// not used | |
| 254 | 1 | tau3 = tau1 / 50;// | |
| 255 | 1 | i = 1. / (2. * M_PI * tau1); | |
| 256 | 1 | j = 1. / (2. * M_PI * tau2); | |
| 257 | 1 | k = 1. / (2. * M_PI * tau3); | |
| 258 | 1 | break; | |
| 259 | ✗ | case 6: //"75µs FM (US)" | |
| 260 | ✗ | tau1 = 0.000075; | |
| 261 | ✗ | tau2 = tau1 / 20;// not used | |
| 262 | ✗ | tau3 = tau1 / 50;// | |
| 263 | ✗ | i = 1. / (2. * M_PI * tau1); | |
| 264 | ✗ | j = 1. / (2. * M_PI * tau2); | |
| 265 | ✗ | k = 1. / (2. * M_PI * tau3); | |
| 266 | ✗ | break; | |
| 267 | } | ||
| 268 | |||
| 269 | 2 | i *= 2 * M_PI; | |
| 270 | 2 | j *= 2 * M_PI; | |
| 271 | 2 | k *= 2 * M_PI; | |
| 272 | |||
| 273 | 2 | t = 1. / sr; | |
| 274 | |||
| 275 | //swap a1 b1, a2 b2 | ||
| 276 |
3/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
|
2 | if (s->type == 7 || s->type == 8) { |
| 277 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | double tau = (s->type == 7 ? 0.000050 : 0.000075); |
| 278 | 1 | double f = 1.0 / (2 * M_PI * tau); | |
| 279 | 1 | double nyq = sr * 0.5; | |
| 280 | 1 | double gain = sqrt(1.0 + nyq * nyq / (f * f)); // gain at Nyquist | |
| 281 | 1 | double cfreq = sqrt((gain - 1.0) * f * f); // frequency | |
| 282 | 1 | double q = 1.0; | |
| 283 | |||
| 284 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (s->type == 8) |
| 285 | 1 | q = pow((sr / 3269.0) + 19.5, -0.25); // somewhat poor curve-fit | |
| 286 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (s->type == 7) |
| 287 | ✗ | q = pow((sr / 4750.0) + 19.5, -0.25); | |
| 288 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (s->mode == 0) |
| 289 | 1 | set_highshelf_rbj(&s->rc.r1, cfreq, q, 1. / gain, sr); | |
| 290 | else | ||
| 291 | ✗ | set_highshelf_rbj(&s->rc.r1, cfreq, q, gain, sr); | |
| 292 | 1 | s->rc.use_brickw = 0; | |
| 293 | } else { | ||
| 294 | 1 | s->rc.use_brickw = 1; | |
| 295 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (s->mode == 0) { // Reproduction |
| 296 | 1 | g = 1. / (4.+2.*i*t+2.*k*t+i*k*t*t); | |
| 297 | 1 | a0 = (2.*t+j*t*t)*g; | |
| 298 | 1 | a1 = (2.*j*t*t)*g; | |
| 299 | 1 | a2 = (-2.*t+j*t*t)*g; | |
| 300 | 1 | b1 = (-8.+2.*i*k*t*t)*g; | |
| 301 | 1 | b2 = (4.-2.*i*t-2.*k*t+i*k*t*t)*g; | |
| 302 | } else { // Production | ||
| 303 | ✗ | g = 1. / (2.*t+j*t*t); | |
| 304 | ✗ | a0 = (4.+2.*i*t+2.*k*t+i*k*t*t)*g; | |
| 305 | ✗ | a1 = (-8.+2.*i*k*t*t)*g; | |
| 306 | ✗ | a2 = (4.-2.*i*t-2.*k*t+i*k*t*t)*g; | |
| 307 | ✗ | b1 = (2.*j*t*t)*g; | |
| 308 | ✗ | b2 = (-2.*t+j*t*t)*g; | |
| 309 | } | ||
| 310 | |||
| 311 | 1 | coeffs.a0 = a0; | |
| 312 | 1 | coeffs.a1 = a1; | |
| 313 | 1 | coeffs.a2 = a2; | |
| 314 | 1 | coeffs.b1 = b1; | |
| 315 | 1 | coeffs.b2 = b2; | |
| 316 | |||
| 317 | // the coeffs above give non-normalized value, so it should be normalized to produce 0dB at 1 kHz | ||
| 318 | // find actual gain | ||
| 319 | // Note: for FM emphasis, use 100 Hz for normalization instead | ||
| 320 | 1 | gain1kHz = freq_gain(&coeffs, 1000.0, sr); | |
| 321 | // divide one filter's x[n-m] coefficients by that value | ||
| 322 | 1 | gc = 1.0 / gain1kHz; | |
| 323 | 1 | s->rc.r1.a0 = coeffs.a0 * gc; | |
| 324 | 1 | s->rc.r1.a1 = coeffs.a1 * gc; | |
| 325 | 1 | s->rc.r1.a2 = coeffs.a2 * gc; | |
| 326 | 1 | s->rc.r1.b1 = coeffs.b1; | |
| 327 | 1 | s->rc.r1.b2 = coeffs.b2; | |
| 328 | } | ||
| 329 | |||
| 330 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | cutfreq = FFMIN(0.45 * sr, 21000.); |
| 331 | 2 | set_lp_rbj(&s->rc.brickw, cutfreq, 0.707, sr, 1.); | |
| 332 | |||
| 333 | 2 | return 0; | |
| 334 | } | ||
| 335 | |||
| 336 | ✗ | static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, | |
| 337 | char *res, int res_len, int flags) | ||
| 338 | { | ||
| 339 | int ret; | ||
| 340 | |||
| 341 | ✗ | ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags); | |
| 342 | ✗ | if (ret < 0) | |
| 343 | ✗ | return ret; | |
| 344 | |||
| 345 | ✗ | return config_input(ctx->inputs[0]); | |
| 346 | } | ||
| 347 | |||
| 348 | 4 | static av_cold void uninit(AVFilterContext *ctx) | |
| 349 | { | ||
| 350 | 4 | AudioEmphasisContext *s = ctx->priv; | |
| 351 | |||
| 352 | 4 | av_frame_free(&s->w); | |
| 353 | 4 | } | |
| 354 | |||
| 355 | static const AVFilterPad avfilter_af_aemphasis_inputs[] = { | ||
| 356 | { | ||
| 357 | .name = "default", | ||
| 358 | .type = AVMEDIA_TYPE_AUDIO, | ||
| 359 | .config_props = config_input, | ||
| 360 | .filter_frame = filter_frame, | ||
| 361 | }, | ||
| 362 | }; | ||
| 363 | |||
| 364 | const AVFilter ff_af_aemphasis = { | ||
| 365 | .name = "aemphasis", | ||
| 366 | .description = NULL_IF_CONFIG_SMALL("Audio emphasis."), | ||
| 367 | .priv_size = sizeof(AudioEmphasisContext), | ||
| 368 | .priv_class = &aemphasis_class, | ||
| 369 | .uninit = uninit, | ||
| 370 | FILTER_INPUTS(avfilter_af_aemphasis_inputs), | ||
| 371 | FILTER_OUTPUTS(ff_audio_default_filterpad), | ||
| 372 | FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_DBLP), | ||
| 373 | .process_command = process_command, | ||
| 374 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | | ||
| 375 | AVFILTER_FLAG_SLICE_THREADS, | ||
| 376 | }; | ||
| 377 |