Unified · Split
| @@ -29,8 +29,7 @@ typedef struct CrystalizerContext { · 28 unmodified lines | |||
| 29 | float mult; | 29 | float mult; |
| 30 | int clip; | 30 | int clip; |
| 31 | AVFrame *prev; | 31 | AVFrame *prev; |
| 32 | void (*filter)(void **dst, void **prv, const void **src, | 32 | int (*filter)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs); |
| 33 | int nb_samples, int channels, float mult, int clip); | ||
| 34 | } CrystalizerContext; | 33 | } CrystalizerContext; |
| 35 | 34 | ||
| 36 | #define OFFSET(x) offsetof(CrystalizerContext, x) | 35 | #define OFFSET(x) offsetof(CrystalizerContext, x) |
| @@ -74,42 +73,71 @@ static int query_formats(AVFilterContext *ctx) · 37 unmodified lines | |||
| 74 | return ff_set_common_samplerates(ctx, formats); | 73 | return ff_set_common_samplerates(ctx, formats); |
| 75 | } | 74 | } |
| 76 | 75 | ||
| 77 | static void filter_flt(void **d, void **p, const void **s, | 76 | typedef struct ThreadData { |
| 78 | int nb_samples, int channels, | 77 | void **d; |
| 79 | float mult, int clip) | 78 | void **p; |
| 79 | const void **s; | ||
| 80 | int nb_samples; | ||
| 81 | int channels; | ||
| 82 | float mult; | ||
| 83 | int clip; | ||
| 84 | } ThreadData; | ||
| 85 | |||
| 86 | static int filter_flt(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) | ||
| 80 | { | 87 | { |
| 81 | const float *src = s[0]; | 88 | ThreadData *td = arg; |
| 82 | float *dst = d[0]; | 89 | void **d = td->d; |
| 90 | void **p = td->p; | ||
| 91 | const void **s = td->s; | ||
| 92 | const int nb_samples = td->nb_samples; | ||
| 93 | const int channels = td->channels; | ||
| 94 | float mult = td->mult; | ||
| 95 | const int clip = td->clip; | ||
| 96 | const int start = (channels * jobnr) / nb_jobs; | ||
| 97 | const int end = (channels * (jobnr+1)) / nb_jobs; | ||
| 83 | float *prv = p[0]; | 98 | float *prv = p[0]; |
| 84 | int n, c; | 99 | int n, c; |
| 85 | 100 | ||
| 86 | for (n = 0; n < nb_samples; n++) { | 101 | for (c = start; c < end; c++) { |
| 87 | for (c = 0; c < channels; c++) { | 102 | const float *src = s[0]; |
| 88 | float current = src[c]; | 103 | float *dst = d[0]; |
| 89 | 104 | ||
| 105 | for (n = 0; n < nb_samples; n++) { | ||
| 106 | float current = src[c]; | ||
| 90 | dst[c] = current + (current - prv[c]) * mult; | 107 | dst[c] = current + (current - prv[c]) * mult; |
| 91 | prv[c] = current; | 108 | prv[c] = current; |
| 92 | if (clip) { | 109 | if (clip) { |
| 93 | dst[c] = av_clipf(dst[c], -1, 1); | 110 | dst[c] = av_clipf(dst[c], -1, 1); |
| 94 | } | 111 | } |
| 95 | } | ||
| 96 | 112 | ||
| 97 | dst += c; | 113 | dst += channels; |
| 98 | src += c; | 114 | src += channels; |
| 115 | } | ||
| 99 | } | 116 | } |
| 117 | |||
| 118 | return 0; | ||
| 100 | } | 119 | } |
| 101 | 120 | ||
| 102 | static void filter_dbl(void **d, void **p, const void **s, | 121 | static int filter_dbl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) |
| 103 | int nb_samples, int channels, | ||
| 104 | float mult, int clip) | ||
| 105 | { | 122 | { |
| 106 | const double *src = s[0]; | 123 | ThreadData *td = arg; |
| 107 | double *dst = d[0]; | 124 | void **d = td->d; |
| 125 | void **p = td->p; | ||
| 126 | const void **s = td->s; | ||
| 127 | const int nb_samples = td->nb_samples; | ||
| 128 | const int channels = td->channels; | ||
| 129 | float mult = td->mult; | ||
| 130 | const int clip = td->clip; | ||
| 131 | const int start = (channels * jobnr) / nb_jobs; | ||
| 132 | const int end = (channels * (jobnr+1)) / nb_jobs; | ||
| 108 | double *prv = p[0]; | 133 | double *prv = p[0]; |
| 109 | int n, c; | 134 | int n, c; |
| 110 | 135 | ||
| 111 | for (n = 0; n < nb_samples; n++) { | 136 | for (c = start; c < end; c++) { |
| 112 | for (c = 0; c < channels; c++) { | 137 | const double *src = s[0]; |
| 138 | double *dst = d[0]; | ||
| 139 | |||
| 140 | for (n = 0; n < nb_samples; n++) { | ||
| 113 | double current = src[c]; | 141 | double current = src[c]; |
| 114 | 142 | ||
| 115 | dst[c] = current + (current - prv[c]) * mult; | 143 | dst[c] = current + (current - prv[c]) * mult; |
| @@ -117,20 +145,30 @@ static void filter_dbl(void **d, void **p, const void **s, · 1 unmodified line | |||
| 117 | if (clip) { | 145 | if (clip) { |
| 118 | dst[c] = av_clipd(dst[c], -1, 1); | 146 | dst[c] = av_clipd(dst[c], -1, 1); |
| 119 | } | 147 | } |
| 120 | } | ||
| 121 | 148 | ||
| 122 | dst += c; | 149 | dst += channels; |
| 123 | src += c; | 150 | src += channels; |
| 151 | } | ||
| 124 | } | 152 | } |
| 153 | |||
| 154 | return 0; | ||
| 125 | } | 155 | } |
| 126 | 156 | ||
| 127 | static void filter_fltp(void **d, void **p, const void **s, | 157 | static int filter_fltp(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) |
| 128 | int nb_samples, int channels, | ||
| 129 | float mult, int clip) | ||
| 130 | { | 158 | { |
| 159 | ThreadData *td = arg; | ||
| 160 | void **d = td->d; | ||
| 161 | void **p = td->p; | ||
| 162 | const void **s = td->s; | ||
| 163 | const int nb_samples = td->nb_samples; | ||
| 164 | const int channels = td->channels; | ||
| 165 | float mult = td->mult; | ||
| 166 | const int clip = td->clip; | ||
| 167 | const int start = (channels * jobnr) / nb_jobs; | ||
| 168 | const int end = (channels * (jobnr+1)) / nb_jobs; | ||
| 131 | int n, c; | 169 | int n, c; |
| 132 | 170 | ||
| 133 | for (c = 0; c < channels; c++) { | 171 | for (c = start; c < end; c++) { |
| 134 | const float *src = s[c]; | 172 | const float *src = s[c]; |
| 135 | float *dst = d[c]; | 173 | float *dst = d[c]; |
| 136 | float *prv = p[c]; | 174 | float *prv = p[c]; |
| @@ -145,15 +183,25 @@ static void filter_fltp(void **d, void **p, const void **s, · 8 unmodified lines | |||
| 145 | } | 183 | } |
| 146 | } | 184 | } |
| 147 | } | 185 | } |
| 186 | |||
| 187 | return 0; | ||
| 148 | } | 188 | } |
| 149 | 189 | ||
| 150 | static void filter_dblp(void **d, void **p, const void **s, | 190 | static int filter_dblp(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) |
| 151 | int nb_samples, int channels, | ||
| 152 | float mult, int clip) | ||
| 153 | { | 191 | { |
| 192 | ThreadData *td = arg; | ||
| 193 | void **d = td->d; | ||
| 194 | void **p = td->p; | ||
| 195 | const void **s = td->s; | ||
| 196 | const int nb_samples = td->nb_samples; | ||
| 197 | const int channels = td->channels; | ||
| 198 | float mult = td->mult; | ||
| 199 | const int clip = td->clip; | ||
| 200 | const int start = (channels * jobnr) / nb_jobs; | ||
| 201 | const int end = (channels * (jobnr+1)) / nb_jobs; | ||
| 154 | int n, c; | 202 | int n, c; |
| 155 | 203 | ||
| 156 | for (c = 0; c < channels; c++) { | 204 | for (c = start; c < end; c++) { |
| 157 | const double *src = s[c]; | 205 | const double *src = s[c]; |
| 158 | double *dst = d[c]; | 206 | double *dst = d[c]; |
| 159 | double *prv = p[c]; | 207 | double *prv = p[c]; |
| @@ -168,6 +216,8 @@ static void filter_dblp(void **d, void **p, const void **s, · 8 unmodified lines | |||
| 168 | } | 216 | } |
| 169 | } | 217 | } |
| 170 | } | 218 | } |
| 219 | |||
| 220 | return 0; | ||
| 171 | } | 221 | } |
| 172 | 222 | ||
| 173 | static int config_input(AVFilterLink *inlink) | 223 | static int config_input(AVFilterLink *inlink) |
| @@ -191,6 +241,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in) · 17 unmodified lines | |||
| 191 | AVFilterLink *outlink = ctx->outputs[0]; | 241 | AVFilterLink *outlink = ctx->outputs[0]; |
| 192 | CrystalizerContext *s = ctx->priv; | 242 | CrystalizerContext *s = ctx->priv; |
| 193 | AVFrame *out; | 243 | AVFrame *out; |
| 244 | ThreadData td; | ||
| 194 | 245 | ||
| 195 | if (!s->prev) { | 246 | if (!s->prev) { |
| 196 | s->prev = ff_get_audio_buffer(inlink, 1); | 247 | s->prev = ff_get_audio_buffer(inlink, 1); |
| @@ -211,8 +262,15 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in) · 14 unmodified lines | |||
| 211 | av_frame_copy_props(out, in); | 262 | av_frame_copy_props(out, in); |
| 212 | } | 263 | } |
| 213 | 264 | ||
| 214 | s->filter((void **)out->extended_data, (void **)s->prev->extended_data, (const void **)in->extended_data, | 265 | td.d = (void **)out->extended_data; |
| 215 | in->nb_samples, in->channels, ctx->is_disabled ? 0.f : s->mult, s->clip); | 266 | td.s = (const void **)in->extended_data; |
| 267 | td.p = (void **)s->prev->extended_data; | ||
| 268 | td.nb_samples = in->nb_samples; | ||
| 269 | td.channels = in->channels; | ||
| 270 | td.mult = ctx->is_disabled ? 0.f : s->mult; | ||
| 271 | td.clip = s->clip; | ||
| 272 | ctx->internal->execute(ctx, s->filter, &td, NULL, FFMIN(inlink->channels, | ||
| 273 | ff_filter_get_nb_threads(ctx))); | ||
| 216 | 274 | ||
| 217 | if (out != in) | 275 | if (out != in) |
| 218 | av_frame_free(&in); | 276 | av_frame_free(&in); |
| @@ -254,6 +312,7 @@ AVFilter ff_af_crystalizer = { · 35 unmodified lines | |||
| 254 | .uninit = uninit, | 312 | .uninit = uninit, |
| 255 | .inputs = inputs, | 313 | .inputs = inputs, |
| 256 | .outputs = outputs, | 314 | .outputs = outputs, |
| 257 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL, | ||
| 258 | .process_command = ff_filter_process_command, | 315 | .process_command = ff_filter_process_command, |
| 316 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | | ||
| 317 | AVFILTER_FLAG_SLICE_THREADS, | ||
| 259 | }; | 318 | }; |