Showing the changes to libavfilter (2 of 3 files). Show all
Unified · Split
| @@ -0,0 +1,270 @@ | ||
| 1 | +/* | |
| 2 | + * This file is part of FFmpeg. | |
| 3 | + * | |
| 4 | + * FFmpeg is free software; you can redistribute it and/or | |
| 5 | + * modify it under the terms of the GNU Lesser General Public | |
| 6 | + * License as published by the Free Software Foundation; either | |
| 7 | + * version 2.1 of the License, or (at your option) any later version. | |
| 8 | + * | |
| 9 | + * FFmpeg is distributed in the hope that it will be useful, | |
| 10 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 11 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 12 | + * Lesser General Public License for more details. | |
| 13 | + * | |
| 14 | + * You should have received a copy of the GNU Lesser General Public | |
| 15 | + * License along with FFmpeg; if not, write to the Free Software | |
| 16 | + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
| 17 | + */ | |
| 18 | + | |
| 19 | +#undef ftype | |
| 20 | +#undef SQRT | |
| 21 | +#undef TAN | |
| 22 | +#undef ONE | |
| 23 | +#undef TWO | |
| 24 | +#undef ZERO | |
| 25 | +#undef FMAX | |
| 26 | +#undef FMIN | |
| 27 | +#undef CLIP | |
| 28 | +#undef SAMPLE_FORMAT | |
| 29 | +#undef FABS | |
| 30 | +#if DEPTH == 32 | |
| 31 | +#define SAMPLE_FORMAT float | |
| 32 | +#define SQRT sqrtf | |
| 33 | +#define TAN tanf | |
| 34 | +#define ONE 1.f | |
| 35 | +#define TWO 2.f | |
| 36 | +#define ZERO 0.f | |
| 37 | +#define FMIN fminf | |
| 38 | +#define FMAX fmaxf | |
| 39 | +#define CLIP av_clipf | |
| 40 | +#define FABS fabsf | |
| 41 | +#define ftype float | |
| 42 | +#else | |
| 43 | +#define SAMPLE_FORMAT double | |
| 44 | +#define SQRT sqrt | |
| 45 | +#define TAN tan | |
| 46 | +#define ONE 1.0 | |
| 47 | +#define TWO 2.0 | |
| 48 | +#define ZERO 0.0 | |
| 49 | +#define FMIN fmin | |
| 50 | +#define FMAX fmax | |
| 51 | +#define CLIP av_clipd | |
| 52 | +#define FABS fabs | |
| 53 | +#define ftype double | |
| 54 | +#endif | |
| 55 | + | |
| 56 | +#define fn3(a,b) a##_##b | |
| 57 | +#define fn2(a,b) fn3(a,b) | |
| 58 | +#define fn(a) fn2(a, SAMPLE_FORMAT) | |
| 59 | + | |
| 60 | +static ftype fn(get_svf)(ftype in, const ftype *m, const ftype *a, ftype *b) | |
| 61 | +{ | |
| 62 | + const ftype v0 = in; | |
| 63 | + const ftype v3 = v0 - b[1]; | |
| 64 | + const ftype v1 = a[0] * b[0] + a[1] * v3; | |
| 65 | + const ftype v2 = b[1] + a[1] * b[0] + a[2] * v3; | |
| 66 | + | |
| 67 | + b[0] = TWO * v1 - b[0]; | |
| 68 | + b[1] = TWO * v2 - b[1]; | |
| 69 | + | |
| 70 | + return m[0] * v0 + m[1] * v1 + m[2] * v2; | |
| 71 | +} | |
| 72 | + | |
| 73 | +static int fn(filter_prepare)(AVFilterContext *ctx) | |
| 74 | +{ | |
| 75 | + AudioDynamicEqualizerContext *s = ctx->priv; | |
| 76 | + const ftype sample_rate = ctx->inputs[0]->sample_rate; | |
| 77 | + const ftype dfrequency = FMIN(s->dfrequency, sample_rate * 0.5); | |
| 78 | + const ftype dg = TAN(M_PI * dfrequency / sample_rate); | |
| 79 | + const ftype dqfactor = s->dqfactor; | |
| 80 | + const int dftype = s->dftype; | |
| 81 | + ftype *da = fn(s->da); | |
| 82 | + ftype *dm = fn(s->dm); | |
| 83 | + ftype k; | |
| 84 | + | |
| 85 | + s->attack_coef = get_coef(s->attack, sample_rate); | |
| 86 | + s->release_coef = get_coef(s->release, sample_rate); | |
| 87 | + | |
| 88 | + switch (dftype) { | |
| 89 | + case 0: | |
| 90 | + k = ONE / dqfactor; | |
| 91 | + | |
| 92 | + da[0] = ONE / (ONE + dg * (dg + k)); | |
| 93 | + da[1] = dg * da[0]; | |
| 94 | + da[2] = dg * da[1]; | |
| 95 | + | |
| 96 | + dm[0] = ZERO; | |
| 97 | + dm[1] = k; | |
| 98 | + dm[2] = ZERO; | |
| 99 | + break; | |
| 100 | + case 1: | |
| 101 | + k = ONE / dqfactor; | |
| 102 | + | |
| 103 | + da[0] = ONE / (ONE + dg * (dg + k)); | |
| 104 | + da[1] = dg * da[0]; | |
| 105 | + da[2] = dg * da[1]; | |
| 106 | + | |
| 107 | + dm[0] = ZERO; | |
| 108 | + dm[1] = ZERO; | |
| 109 | + dm[2] = ONE; | |
| 110 | + break; | |
| 111 | + case 2: | |
| 112 | + k = ONE / dqfactor; | |
| 113 | + | |
| 114 | + da[0] = ONE / (ONE + dg * (dg + k)); | |
| 115 | + da[1] = dg * da[0]; | |
| 116 | + da[2] = dg * da[1]; | |
| 117 | + | |
| 118 | + dm[0] = ZERO; | |
| 119 | + dm[1] = -k; | |
| 120 | + dm[2] = -ONE; | |
| 121 | + break; | |
| 122 | + case 3: | |
| 123 | + k = ONE / dqfactor; | |
| 124 | + | |
| 125 | + da[0] = ONE / (ONE + dg * (dg + k)); | |
| 126 | + da[1] = dg * da[0]; | |
| 127 | + da[2] = dg * da[1]; | |
| 128 | + | |
| 129 | + dm[0] = ZERO; | |
| 130 | + dm[1] = -k; | |
| 131 | + dm[2] = -TWO; | |
| 132 | + break; | |
| 133 | + } | |
| 134 | + | |
| 135 | + return 0; | |
| 136 | +} | |
| 137 | + | |
| 138 | +static int fn(filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) | |
| 139 | +{ | |
| 140 | + AudioDynamicEqualizerContext *s = ctx->priv; | |
| 141 | + ThreadData *td = arg; | |
| 142 | + AVFrame *in = td->in; | |
| 143 | + AVFrame *out = td->out; | |
| 144 | + const ftype sample_rate = in->sample_rate; | |
| 145 | + const ftype makeup = s->makeup; | |
| 146 | + const ftype ratio = s->ratio; | |
| 147 | + const ftype range = s->range; | |
| 148 | + const ftype tfrequency = FMIN(s->tfrequency, sample_rate * 0.5); | |
| 149 | + const ftype release = s->release_coef; | |
| 150 | + const ftype irelease = ONE - release; | |
| 151 | + const ftype attack = s->attack_coef; | |
| 152 | + const ftype iattack = ONE - attack; | |
| 153 | + const ftype tqfactor = s->tqfactor; | |
| 154 | + const ftype itqfactor = ONE / tqfactor; | |
| 155 | + const ftype fg = TAN(M_PI * tfrequency / sample_rate); | |
| 156 | + const int start = (in->ch_layout.nb_channels * jobnr) / nb_jobs; | |
| 157 | + const int end = (in->ch_layout.nb_channels * (jobnr+1)) / nb_jobs; | |
| 158 | + const int detection = s->detection; | |
| 159 | + const int direction = s->direction; | |
| 160 | + const int tftype = s->tftype; | |
| 161 | + const int mode = s->mode; | |
| 162 | + const ftype *da = fn(s->da); | |
| 163 | + const ftype *dm = fn(s->dm); | |
| 164 | + | |
| 165 | + for (int ch = start; ch < end; ch++) { | |
| 166 | + const ftype *src = (const ftype *)in->extended_data[ch]; | |
| 167 | + ftype *dst = (ftype *)out->extended_data[ch]; | |
| 168 | + ftype *state = (ftype *)s->state->extended_data[ch]; | |
| 169 | + const ftype threshold = detection == 0 ? state[5] : s->threshold; | |
| 170 | + | |
| 171 | + if (detection < 0) | |
| 172 | + state[5] = threshold; | |
| 173 | + | |
| 174 | + for (int n = 0; n < out->nb_samples; n++) { | |
| 175 | + ftype detect, gain, v, listen; | |
| 176 | + ftype fa[3], fm[3]; | |
| 177 | + ftype k, g; | |
| 178 | + | |
| 179 | + detect = listen = fn(get_svf)(src[n], dm, da, state); | |
| 180 | + detect = FABS(detect); | |
| 181 | + | |
| 182 | + if (detection > 0) | |
| 183 | + state[5] = FMAX(state[5], detect); | |
| 184 | + | |
| 185 | + if (direction == 0) { | |
| 186 | + if (detect < threshold) { | |
| 187 | + if (mode == 0) | |
| 188 | + detect = ONE / CLIP(ONE + makeup + (threshold - detect) * ratio, ONE, range); | |
| 189 | + else | |
| 190 | + detect = CLIP(ONE + makeup + (threshold - detect) * ratio, ONE, range); | |
| 191 | + } else { | |
| 192 | + detect = ONE; | |
| 193 | + } | |
| 194 | + } else { | |
| 195 | + if (detect > threshold) { | |
| 196 | + if (mode == 0) | |
| 197 | + detect = ONE / CLIP(ONE + makeup + (detect - threshold) * ratio, ONE, range); | |
| 198 | + else | |
| 199 | + detect = CLIP(ONE + makeup + (detect - threshold) * ratio, ONE, range); | |
| 200 | + } else { | |
| 201 | + detect = ONE; | |
| 202 | + } | |
| 203 | + } | |
| 204 | + | |
| 205 | + if (direction == 0) { | |
| 206 | + if (detect > state[4]) { | |
| 207 | + detect = iattack * detect + attack * state[4]; | |
| 208 | + } else { | |
| 209 | + detect = irelease * detect + release * state[4]; | |
| 210 | + } | |
| 211 | + } else { | |
| 212 | + if (detect < state[4]) { | |
| 213 | + detect = iattack * detect + attack * state[4]; | |
| 214 | + } else { | |
| 215 | + detect = irelease * detect + release * state[4]; | |
| 216 | + } | |
| 217 | + } | |
| 218 | + | |
| 219 | + if (state[4] != detect || n == 0) { | |
| 220 | + state[4] = gain = detect; | |
| 221 | + | |
| 222 | + switch (tftype) { | |
| 223 | + case 0: | |
| 224 | + k = ONE / (tqfactor * gain); | |
| 225 | + | |
| 226 | + fa[0] = ONE / (ONE + fg * (fg + k)); | |
| 227 | + fa[1] = fg * fa[0]; | |
| 228 | + fa[2] = fg * fa[1]; | |
| 229 | + | |
| 230 | + fm[0] = ONE; | |
| 231 | + fm[1] = k * (gain * gain - ONE); | |
| 232 | + fm[2] = ZERO; | |
| 233 | + break; | |
| 234 | + case 1: | |
| 235 | + k = itqfactor; | |
| 236 | + g = fg / SQRT(gain); | |
| 237 | + | |
| 238 | + fa[0] = ONE / (ONE + g * (g + k)); | |
| 239 | + fa[1] = g * fa[0]; | |
| 240 | + fa[2] = g * fa[1]; | |
| 241 | + | |
| 242 | + fm[0] = ONE; | |
| 243 | + fm[1] = k * (gain - ONE); | |
| 244 | + fm[2] = gain * gain - ONE; | |
| 245 | + break; | |
| 246 | + case 2: | |
| 247 | + k = itqfactor; | |
| 248 | + g = fg / SQRT(gain); | |
| 249 | + | |
| 250 | + fa[0] = ONE / (ONE + g * (g + k)); | |
| 251 | + fa[1] = g * fa[0]; | |
| 252 | + fa[2] = g * fa[1]; | |
| 253 | + | |
| 254 | + fm[0] = gain * gain; | |
| 255 | + fm[1] = k * (ONE - gain) * gain; | |
| 256 | + fm[2] = ONE - gain * gain; | |
| 257 | + break; | |
| 258 | + } | |
| 259 | + } | |
| 260 | + | |
| 261 | + v = fn(get_svf)(src[n], fm, fa, &state[2]); | |
| 262 | + v = mode == -1 ? listen : v; | |
| 263 | + dst[n] = ctx->is_disabled ? src[n] : v; | |
| 264 | + } | |
| 265 | + } | |
| 266 | + | |
| 267 | + return 0; | |
| 268 | +} | |
| 269 | + | |
| 270 | + | |
| @@ -43,242 +43,82 @@ typedef struct AudioDynamicEqualizerContext { · 42 unmodified lines | ||
| 43 | 43 | int detection; |
| 44 | 44 | int tftype; |
| 45 | 45 | int dftype; |
| 46 | + int precision; | |
| 47 | + int format; | |
| 48 | + | |
| 49 | + int (*filter_prepare)(AVFilterContext *ctx); | |
| 50 | + int (*filter_channels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs); | |
| 51 | + | |
| 52 | + double da_double[3], dm_double[3]; | |
| 53 | + float da_float[3], dm_float[3]; | |
| 46 | 54 | |
| 47 | − double da[3], dm[3]; | |
| 48 | 55 | AVFrame *state; |
| 49 | 56 | } AudioDynamicEqualizerContext; |
| 50 | 57 | |
| 51 | −static int config_input(AVFilterLink *inlink) | |
| 58 | +static int query_formats(AVFilterContext *ctx) | |
| 52 | 59 | { |
| 53 | − AVFilterContext *ctx = inlink->dst; | |
| 54 | 60 | AudioDynamicEqualizerContext *s = ctx->priv; |
| 61 | + static const enum AVSampleFormat sample_fmts[3][3] = { | |
| 62 | + { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE }, | |
| 63 | + { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE }, | |
| 64 | + { AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE }, | |
| 65 | + }; | |
| 66 | + int ret; | |
| 55 | 67 | |
| 56 | − s->state = ff_get_audio_buffer(inlink, 8); | |
| 57 | − if (!s->state) | |
| 58 | − return AVERROR(ENOMEM); | |
| 59 | − | |
| 60 | − for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { | |
| 61 | − double *state = (double *)s->state->extended_data[ch]; | |
| 68 | + if ((ret = ff_set_common_all_channel_counts(ctx)) < 0) | |
| 69 | + return ret; | |
| 62 | 70 | |
| 63 | − state[4] = 1.; | |
| 64 | − } | |
| 71 | + if ((ret = ff_set_common_formats_from_list(ctx, sample_fmts[s->precision])) < 0) | |
| 72 | + return ret; | |
| 65 | 73 | |
| 66 | − return 0; | |
| 74 | + return ff_set_common_all_samplerates(ctx); | |
| 67 | 75 | } |
| 68 | 76 | |
| 69 | −static double get_svf(double in, const double *m, const double *a, double *b) | |
| 77 | +static double get_coef(double x, double sr) | |
| 70 | 78 | { |
| 71 | − const double v0 = in; | |
| 72 | − const double v3 = v0 - b[1]; | |
| 73 | − const double v1 = a[0] * b[0] + a[1] * v3; | |
| 74 | − const double v2 = b[1] + a[1] * b[0] + a[2] * v3; | |
| 75 | − | |
| 76 | − b[0] = 2. * v1 - b[0]; | |
| 77 | − b[1] = 2. * v2 - b[1]; | |
| 78 | − | |
| 79 | − return m[0] * v0 + m[1] * v1 + m[2] * v2; | |
| 79 | + return exp(-1000. / (x * sr)); | |
| 80 | 80 | } |
| 81 | 81 | |
| 82 | 82 | typedef struct ThreadData { |
| 83 | 83 | AVFrame *in, *out; |
| 84 | 84 | } ThreadData; |
| 85 | 85 | |
| 86 | −static double get_coef(double x, double sr) | |
| 87 | −{ | |
| 88 | − return exp(-1000. / (x * sr)); | |
| 89 | −} | |
| 86 | +#define DEPTH 32 | |
| 87 | +#include "adynamicequalizer_template.c" | |
| 90 | 88 | |
| 91 | −static int filter_prepare(AVFilterContext *ctx) | |
| 89 | +#undef DEPTH | |
| 90 | +#define DEPTH 64 | |
| 91 | +#include "adynamicequalizer_template.c" | |
| 92 | + | |
| 93 | +static int config_input(AVFilterLink *inlink) | |
| 92 | 94 | { |
| 95 | + AVFilterContext *ctx = inlink->dst; | |
| 93 | 96 | AudioDynamicEqualizerContext *s = ctx->priv; |
| 94 | − const double sample_rate = ctx->inputs[0]->sample_rate; | |
| 95 | − const double dfrequency = fmin(s->dfrequency, sample_rate * 0.5); | |
| 96 | − const double dg = tan(M_PI * dfrequency / sample_rate); | |
| 97 | − const double dqfactor = s->dqfactor; | |
| 98 | − const int dftype = s->dftype; | |
| 99 | − double *da = s->da; | |
| 100 | − double *dm = s->dm; | |
| 101 | − double k; | |
| 102 | − | |
| 103 | − s->attack_coef = get_coef(s->attack, sample_rate); | |
| 104 | − s->release_coef = get_coef(s->release, sample_rate); | |
| 105 | − | |
| 106 | − switch (dftype) { | |
| 107 | − case 0: | |
| 108 | − k = 1. / dqfactor; | |
| 109 | − | |
| 110 | − da[0] = 1. / (1. + dg * (dg + k)); | |
| 111 | − da[1] = dg * da[0]; | |
| 112 | − da[2] = dg * da[1]; | |
| 113 | − | |
| 114 | − dm[0] = 0.; | |
| 115 | − dm[1] = k; | |
| 116 | − dm[2] = 0.; | |
| 117 | − break; | |
| 118 | − case 1: | |
| 119 | − k = 1. / dqfactor; | |
| 120 | − | |
| 121 | − da[0] = 1. / (1. + dg * (dg + k)); | |
| 122 | − da[1] = dg * da[0]; | |
| 123 | − da[2] = dg * da[1]; | |
| 124 | − | |
| 125 | − dm[0] = 0.; | |
| 126 | − dm[1] = 0.; | |
| 127 | − dm[2] = 1.; | |
| 128 | − break; | |
| 129 | − case 2: | |
| 130 | − k = 1. / dqfactor; | |
| 131 | 97 | |
| 132 | − da[0] = 1. / (1. + dg * (dg + k)); | |
| 133 | − da[1] = dg * da[0]; | |
| 134 | − da[2] = dg * da[1]; | |
| 135 | − | |
| 136 | − dm[0] = 0.; | |
| 137 | − dm[1] = -k; | |
| 138 | − dm[2] = -1.; | |
| 139 | − break; | |
| 140 | − case 3: | |
| 141 | − k = 1. / dqfactor; | |
| 98 | + s->format = inlink->format; | |
| 99 | + s->state = ff_get_audio_buffer(inlink, 8); | |
| 100 | + if (!s->state) | |
| 101 | + return AVERROR(ENOMEM); | |
| 142 | 102 | |
| 143 | − da[0] = 1. / (1. + dg * (dg + k)); | |
| 144 | − da[1] = dg * da[0]; | |
| 145 | − da[2] = dg * da[1]; | |
| 103 | + switch (s->format) { | |
| 104 | + case AV_SAMPLE_FMT_DBLP: | |
| 105 | + for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { | |
| 106 | + double *state = (double *)s->state->extended_data[ch]; | |
| 146 | 107 | |
| 147 | − dm[0] = 0.; | |
| 148 | − dm[1] = -k; | |
| 149 | − dm[2] = -2.; | |
| 108 | + state[4] = 1.; | |
| 109 | + } | |
| 110 | + s->filter_prepare = filter_prepare_double; | |
| 111 | + s->filter_channels = filter_channels_double; | |
| 150 | 112 | break; |
| 151 | − } | |
| 152 | − | |
| 153 | − return 0; | |
| 154 | −} | |
| 113 | + case AV_SAMPLE_FMT_FLTP: | |
| 114 | + for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { | |
| 115 | + float *state = (float *)s->state->extended_data[ch]; | |
| 155 | 116 | |
| 156 | −static int filter_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) | |
| 157 | −{ | |
| 158 | − AudioDynamicEqualizerContext *s = ctx->priv; | |
| 159 | − ThreadData *td = arg; | |
| 160 | − AVFrame *in = td->in; | |
| 161 | − AVFrame *out = td->out; | |
| 162 | − const double sample_rate = in->sample_rate; | |
| 163 | − const double makeup = s->makeup; | |
| 164 | − const double ratio = s->ratio; | |
| 165 | − const double range = s->range; | |
| 166 | − const double tfrequency = fmin(s->tfrequency, sample_rate * 0.5); | |
| 167 | − const double release = s->release_coef; | |
| 168 | − const double irelease = 1. - release; | |
| 169 | − const double attack = s->attack_coef; | |
| 170 | − const double iattack = 1. - attack; | |
| 171 | − const double tqfactor = s->tqfactor; | |
| 172 | − const double fg = tan(M_PI * tfrequency / sample_rate); | |
| 173 | − const int start = (in->ch_layout.nb_channels * jobnr) / nb_jobs; | |
| 174 | − const int end = (in->ch_layout.nb_channels * (jobnr+1)) / nb_jobs; | |
| 175 | − const int detection = s->detection; | |
| 176 | − const int direction = s->direction; | |
| 177 | − const int tftype = s->tftype; | |
| 178 | − const int mode = s->mode; | |
| 179 | − const double *da = s->da; | |
| 180 | − const double *dm = s->dm; | |
| 181 | − | |
| 182 | − for (int ch = start; ch < end; ch++) { | |
| 183 | − const double *src = (const double *)in->extended_data[ch]; | |
| 184 | − double *dst = (double *)out->extended_data[ch]; | |
| 185 | − double *state = (double *)s->state->extended_data[ch]; | |
| 186 | − const double threshold = detection == 0 ? state[5] : s->threshold; | |
| 187 | − | |
| 188 | − if (detection < 0) | |
| 189 | − state[5] = threshold; | |
| 190 | − | |
| 191 | − for (int n = 0; n < out->nb_samples; n++) { | |
| 192 | − double detect, gain, v, listen; | |
| 193 | − double fa[3], fm[3]; | |
| 194 | − double k, g; | |
| 195 | − | |
| 196 | − detect = listen = get_svf(src[n], dm, da, state); | |
| 197 | − detect = fabs(detect); | |
| 198 | − | |
| 199 | − if (detection > 0) | |
| 200 | − state[5] = fmax(state[5], detect); | |
| 201 | − | |
| 202 | − if (direction == 0) { | |
| 203 | − if (detect < threshold) { | |
| 204 | − if (mode == 0) | |
| 205 | − detect = 1. / av_clipd(1. + makeup + (threshold - detect) * ratio, 1., range); | |
| 206 | − else | |
| 207 | − detect = av_clipd(1. + makeup + (threshold - detect) * ratio, 1., range); | |
| 208 | − } else { | |
| 209 | − detect = 1.; | |
| 210 | − } | |
| 211 | − } else { | |
| 212 | − if (detect > threshold) { | |
| 213 | − if (mode == 0) | |
| 214 | − detect = 1. / av_clipd(1. + makeup + (detect - threshold) * ratio, 1., range); | |
| 215 | − else | |
| 216 | − detect = av_clipd(1. + makeup + (detect - threshold) * ratio, 1., range); | |
| 217 | − } else { | |
| 218 | − detect = 1.; | |
| 219 | − } | |
| 220 | − } | |
| 221 | − | |
| 222 | − if (direction == 0) { | |
| 223 | − if (detect > state[4]) { | |
| 224 | − detect = iattack * detect + attack * state[4]; | |
| 225 | − } else { | |
| 226 | − detect = irelease * detect + release * state[4]; | |
| 227 | − } | |
| 228 | − } else { | |
| 229 | − if (detect < state[4]) { | |
| 230 | − detect = iattack * detect + attack * state[4]; | |
| 231 | − } else { | |
| 232 | − detect = irelease * detect + release * state[4]; | |
| 233 | − } | |
| 234 | − } | |
| 235 | − | |
| 236 | − if (state[4] != detect || n == 0) { | |
| 237 | − state[4] = gain = detect; | |
| 238 | − | |
| 239 | − switch (tftype) { | |
| 240 | − case 0: | |
| 241 | − k = 1. / (tqfactor * gain); | |
| 242 | − | |
| 243 | − fa[0] = 1. / (1. + fg * (fg + k)); | |
| 244 | − fa[1] = fg * fa[0]; | |
| 245 | − fa[2] = fg * fa[1]; | |
| 246 | − | |
| 247 | − fm[0] = 1.; | |
| 248 | − fm[1] = k * (gain * gain - 1.); | |
| 249 | − fm[2] = 0.; | |
| 250 | − break; | |
| 251 | − case 1: | |
| 252 | − k = 1. / tqfactor; | |
| 253 | − g = fg / sqrt(gain); | |
| 254 | − | |
| 255 | − fa[0] = 1. / (1. + g * (g + k)); | |
| 256 | − fa[1] = g * fa[0]; | |
| 257 | − fa[2] = g * fa[1]; | |
| 258 | − | |
| 259 | − fm[0] = 1.; | |
| 260 | − fm[1] = k * (gain - 1.); | |
| 261 | − fm[2] = gain * gain - 1.; | |
| 262 | − break; | |
| 263 | − case 2: | |
| 264 | − k = 1. / tqfactor; | |
| 265 | − g = fg / sqrt(gain); | |
| 266 | − | |
| 267 | − fa[0] = 1. / (1. + g * (g + k)); | |
| 268 | − fa[1] = g * fa[0]; | |
| 269 | − fa[2] = g * fa[1]; | |
| 270 | − | |
| 271 | − fm[0] = gain * gain; | |
| 272 | − fm[1] = k * (1. - gain) * gain; | |
| 273 | − fm[2] = 1. - gain * gain; | |
| 274 | − break; | |
| 275 | − } | |
| 276 | − } | |
| 277 | − | |
| 278 | − v = get_svf(src[n], fm, fa, &state[2]); | |
| 279 | − v = mode == -1 ? listen : v; | |
| 280 | − dst[n] = ctx->is_disabled ? src[n] : v; | |
| 117 | + state[4] = 1.; | |
| 281 | 118 | } |
| 119 | + s->filter_prepare = filter_prepare_float; | |
| 120 | + s->filter_channels = filter_channels_float; | |
| 121 | + break; | |
| 282 | 122 | } |
| 283 | 123 | |
| 284 | 124 | return 0; |
| @@ -288,6 +128,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in) · 3 unmodified lines | ||
| 288 | 128 | { |
| 289 | 129 | AVFilterContext *ctx = inlink->dst; |
| 290 | 130 | AVFilterLink *outlink = ctx->outputs[0]; |
| 131 | + AudioDynamicEqualizerContext *s = ctx->priv; | |
| 291 | 132 | ThreadData td; |
| 292 | 133 | AVFrame *out; |
| 293 | 134 | |
| @@ -304,8 +145,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in) · 10 unmodified lines | ||
| 304 | 145 | |
| 305 | 146 | td.in = in; |
| 306 | 147 | td.out = out; |
| 307 | − filter_prepare(ctx); | |
| 308 | − ff_filter_execute(ctx, filter_channels, &td, NULL, | |
| 148 | + s->filter_prepare(ctx); | |
| 149 | + ff_filter_execute(ctx, s->filter_channels, &td, NULL, | |
| 309 | 150 | FFMIN(outlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx))); |
| 310 | 151 | |
| 311 | 152 | if (out != in) |
| @@ -321,6 +162,7 @@ static av_cold void uninit(AVFilterContext *ctx) · 9 unmodified lines | ||
| 321 | 162 | } |
| 322 | 163 | |
| 323 | 164 | #define OFFSET(x) offsetof(AudioDynamicEqualizerContext, x) |
| 165 | +#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM | |
| 324 | 166 | #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM |
| 325 | 167 | |
| 326 | 168 | static const AVOption adynamicequalizer_options[] = { |
| @@ -354,6 +196,10 @@ static const AVOption adynamicequalizer_options[] = { · 27 unmodified lines | ||
| 354 | 196 | { "disabled", 0, 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, "auto" }, |
| 355 | 197 | { "off", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "auto" }, |
| 356 | 198 | { "on", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "auto" }, |
| 199 | + { "precision", "set processing precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, AF, "precision" }, | |
| 200 | + { "auto", "set auto processing precision", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, "precision" }, | |
| 201 | + { "float", "set single-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, "precision" }, | |
| 202 | + { "double","set double-floating point processing precision", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, "precision" }, | |
| 357 | 203 | { NULL } |
| 358 | 204 | }; |
| 359 | 205 | |
| @@ -383,7 +229,7 @@ const AVFilter ff_af_adynamicequalizer = { · 23 unmodified lines | ||
| 383 | 229 | .uninit = uninit, |
| 384 | 230 | FILTER_INPUTS(inputs), |
| 385 | 231 | FILTER_OUTPUTS(outputs), |
| 386 | − FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_DBLP), | |
| 232 | + FILTER_QUERY_FUNC(query_formats), | |
| 387 | 233 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | |
| 388 | 234 | AVFILTER_FLAG_SLICE_THREADS, |
| 389 | 235 | .process_command = ff_filter_process_command, |