1 /*
2 * Copyright (c) 2016 The FFmpeg Project
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/channel_layout.h"
22 #include "libavutil/opt.h"
23 #include "avfilter.h"
24 #include "audio.h"
25 #include "formats.h"
26
27 typedef struct CrystalizerContext {
28 const AVClass *class;
29 float mult;
30 int clip;
31 AVFrame *prev;
32 int (*filter[2][2])(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
33 } CrystalizerContext;
34
35 #define OFFSET(x) offsetof(CrystalizerContext, x)
36 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
37
38 static const AVOption crystalizer_options[] = {
39 { "i", "set intensity", OFFSET(mult), AV_OPT_TYPE_FLOAT, {.dbl=2.0},-10, 10, A },
40 { "c", "enable clipping", OFFSET(clip), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, A },
41 { NULL }
42 };
43
44 AVFILTER_DEFINE_CLASS(crystalizer);
45
46 typedef struct ThreadData {
47 void **d;
48 void **p;
49 const void **s;
50 int nb_samples;
51 int channels;
52 float mult;
53 } ThreadData;
54
55 #define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed) \
56 static int filter_## inverse ##_## fmt ##_## clp(AVFilterContext *ctx, \
57 void *arg, int jobnr,\
58 int nb_jobs) \
59 { \
60 ThreadData *td = arg; \
61 void **d = td->d; \
62 void **p = td->p; \
63 const void **s = td->s; \
64 const int nb_samples = td->nb_samples; \
65 const int channels = td->channels; \
66 const type mult = td->mult; \
67 const type scale = one / (-mult + one); \
68 const int start = (channels * jobnr) / nb_jobs; \
69 const int end = (channels * (jobnr+1)) / nb_jobs; \
70 \
71 if (packed) { \
72 type *prv = p[0]; \
73 for (int c = start; c < end; c++) { \
74 const type *src = s[0]; \
75 type *dst = d[0]; \
76 \
77 for (int n = 0; n < nb_samples; n++) { \
78 type current = src[c]; \
79 \
80 if (inverset) { \
81 dst[c] = (current - prv[c] * mult) * scale; \
82 prv[c] = dst[c]; \
83 } else { \
84 dst[c] = current + (current - prv[c]) * mult; \
85 prv[c] = current; \
86 } \
87 if (clip) { \
88 dst[c] = clip_fn(dst[c], -one, one); \
89 } \
90 \
91 dst += channels; \
92 src += channels; \
93 } \
94 } \
95 } else { \
96 for (int c = start; c < end; c++) { \
97 const type *src = s[c]; \
98 type *dst = d[c]; \
99 type *prv = p[c]; \
100 \
101 for (int n = 0; n < nb_samples; n++) { \
102 type current = src[n]; \
103 \
104 if (inverset) { \
105 dst[n] = (current - prv[0] * mult) * scale; \
106 prv[0] = dst[n]; \
107 } else { \
108 dst[n] = current + (current - prv[0]) * mult; \
109 prv[0] = current; \
110 } \
111 if (clip) { \
112 dst[n] = clip_fn(dst[n], -one, one); \
113 } \
114 } \
115 } \
116 } \
117 \
118 return 0; \
119 }
120
121 filters(flt, float, inverse, noclip, 1, 0, 1.f, av_clipf, 1)
122 filters(flt, float, inverse, clip, 1, 1, 1.f, av_clipf, 1)
123 filters(flt, float, noinverse, noclip, 0, 0, 1.f, av_clipf, 1)
124 filters(flt, float, noinverse, clip, 0, 1, 1.f, av_clipf, 1)
125
126 filters(fltp, float, inverse, noclip, 1, 0, 1.f, av_clipf, 0)
127 filters(fltp, float, inverse, clip, 1, 1, 1.f, av_clipf, 0)
128 filters(fltp, float, noinverse, noclip, 0, 0, 1.f, av_clipf, 0)
129 filters(fltp, float, noinverse, clip, 0, 1, 1.f, av_clipf, 0)
130
131 filters(dbl, double, inverse, noclip, 1, 0, 1.0, av_clipd, 1)
132 filters(dbl, double, inverse, clip, 1, 1, 1.0, av_clipd, 1)
133 filters(dbl, double, noinverse, noclip, 0, 0, 1.0, av_clipd, 1)
134 filters(dbl, double, noinverse, clip, 0, 1, 1.0, av_clipd, 1)
135
136 filters(dblp, double, inverse, noclip, 1, 0, 1.0, av_clipd, 0)
137 filters(dblp, double, inverse, clip, 1, 1, 1.0, av_clipd, 0)
138 filters(dblp, double, noinverse, noclip, 0, 0, 1.0, av_clipd, 0)
139 filters(dblp, double, noinverse, clip, 0, 1, 1.0, av_clipd, 0)
140
config_input(AVFilterLink * inlink)141 static int config_input(AVFilterLink *inlink)
142 {
143 AVFilterContext *ctx = inlink->dst;
144 CrystalizerContext *s = ctx->priv;
145
146 switch (inlink->format) {
147 case AV_SAMPLE_FMT_FLT:
148 s->filter[0][0] = filter_inverse_flt_noclip;
149 s->filter[1][0] = filter_noinverse_flt_noclip;
150 s->filter[0][1] = filter_inverse_flt_clip;
151 s->filter[1][1] = filter_noinverse_flt_clip;
152 break;
153 case AV_SAMPLE_FMT_FLTP:
154 s->filter[0][0] = filter_inverse_fltp_noclip;
155 s->filter[1][0] = filter_noinverse_fltp_noclip;
156 s->filter[0][1] = filter_inverse_fltp_clip;
157 s->filter[1][1] = filter_noinverse_fltp_clip;
158 break;
159 case AV_SAMPLE_FMT_DBL:
160 s->filter[0][0] = filter_inverse_dbl_noclip;
161 s->filter[1][0] = filter_noinverse_dbl_noclip;
162 s->filter[0][1] = filter_inverse_dbl_clip;
163 s->filter[1][1] = filter_noinverse_dbl_clip;
164 break;
165 case AV_SAMPLE_FMT_DBLP:
166 s->filter[0][0] = filter_inverse_dblp_noclip;
167 s->filter[1][0] = filter_noinverse_dblp_noclip;
168 s->filter[0][1] = filter_inverse_dblp_clip;
169 s->filter[1][1] = filter_noinverse_dblp_clip;
170 break;
171 default:
172 return AVERROR_BUG;
173 }
174
175 return 0;
176 }
177
filter_frame(AVFilterLink * inlink,AVFrame * in)178 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
179 {
180 AVFilterContext *ctx = inlink->dst;
181 AVFilterLink *outlink = ctx->outputs[0];
182 CrystalizerContext *s = ctx->priv;
183 AVFrame *out;
184 ThreadData td;
185
186 if (!s->prev) {
187 s->prev = ff_get_audio_buffer(inlink, 1);
188 if (!s->prev) {
189 av_frame_free(&in);
190 return AVERROR(ENOMEM);
191 }
192 }
193
194 if (av_frame_is_writable(in)) {
195 out = in;
196 } else {
197 out = ff_get_audio_buffer(outlink, in->nb_samples);
198 if (!out) {
199 av_frame_free(&in);
200 return AVERROR(ENOMEM);
201 }
202 av_frame_copy_props(out, in);
203 }
204
205 td.d = (void **)out->extended_data;
206 td.s = (const void **)in->extended_data;
207 td.p = (void **)s->prev->extended_data;
208 td.nb_samples = in->nb_samples;
209 td.channels = in->ch_layout.nb_channels;
210 td.mult = ctx->is_disabled ? 0.f : s->mult;
211 ff_filter_execute(ctx, s->filter[td.mult >= 0.f][s->clip], &td, NULL,
212 FFMIN(inlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
213
214 if (out != in)
215 av_frame_free(&in);
216
217 return ff_filter_frame(outlink, out);
218 }
219
uninit(AVFilterContext * ctx)220 static av_cold void uninit(AVFilterContext *ctx)
221 {
222 CrystalizerContext *s = ctx->priv;
223
224 av_frame_free(&s->prev);
225 }
226
227 static const AVFilterPad inputs[] = {
228 {
229 .name = "default",
230 .type = AVMEDIA_TYPE_AUDIO,
231 .filter_frame = filter_frame,
232 .config_props = config_input,
233 },
234 };
235
236 static const AVFilterPad outputs[] = {
237 {
238 .name = "default",
239 .type = AVMEDIA_TYPE_AUDIO,
240 },
241 };
242
243 const AVFilter ff_af_crystalizer = {
244 .name = "crystalizer",
245 .description = NULL_IF_CONFIG_SMALL("Simple audio noise sharpening filter."),
246 .priv_size = sizeof(CrystalizerContext),
247 .priv_class = &crystalizer_class,
248 .uninit = uninit,
249 FILTER_INPUTS(inputs),
250 FILTER_OUTPUTS(outputs),
251 FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
252 AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP),
253 .process_command = ff_filter_process_command,
254 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
255 AVFILTER_FLAG_SLICE_THREADS,
256 };
257