FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/af_crystalizer.c
Date: 2024-07-16 12:46:59
Exec Total Coverage
Lines: 36 78 46.2%
Functions: 5 19 26.3%
Branches: 16 83 19.3%

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