FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_limiter.c
Date: 2022-12-05 03:11:11
Exec Total Coverage
Lines: 0 69 0.0%
Functions: 0 7 0.0%
Branches: 0 34 0.0%

Line Branch Exec Source
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 #include "libavutil/attributes.h"
20 #include "libavutil/common.h"
21 #include "libavutil/imgutils.h"
22 #include "libavutil/opt.h"
23 #include "libavutil/pixdesc.h"
24 #include "avfilter.h"
25 #include "formats.h"
26 #include "internal.h"
27 #include "limiter.h"
28 #include "video.h"
29
30 typedef struct ThreadData {
31 AVFrame *in;
32 AVFrame *out;
33 } ThreadData;
34
35 typedef struct LimiterContext {
36 const AVClass *class;
37 int min;
38 int max;
39 int planes;
40 int nb_planes;
41 int linesize[4];
42 int width[4];
43 int height[4];
44
45 LimiterDSPContext dsp;
46 } LimiterContext;
47
48 #define OFFSET(x) offsetof(LimiterContext, x)
49 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
50
51 static const AVOption limiter_options[] = {
52 { "min", "set min value", OFFSET(min), AV_OPT_TYPE_INT, {.i64=0}, 0, 65535, .flags = FLAGS },
53 { "max", "set max value", OFFSET(max), AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, .flags = FLAGS },
54 { "planes", "set planes", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=15}, 0, 15, .flags = FLAGS },
55 { NULL }
56 };
57
58 AVFILTER_DEFINE_CLASS(limiter);
59
60 static av_cold int init(AVFilterContext *ctx)
61 {
62 LimiterContext *s = ctx->priv;
63
64 if (s->min > s->max)
65 return AVERROR(EINVAL);
66 return 0;
67 }
68
69 static const enum AVPixelFormat pix_fmts[] = {
70 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
71 AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
72 AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
73 AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
74 AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
75 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
76 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
77 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
78 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
79 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
80 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
81 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
82 AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
83 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
84 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
85 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
86 AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
87 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
88 AV_PIX_FMT_NONE
89 };
90
91 #define LIMITER(n, type) \
92 static void limiter##n(const uint8_t *ssrc, uint8_t *ddst, \
93 ptrdiff_t slinesize, ptrdiff_t dlinesize,\
94 int w, int h, int min, int max) \
95 { \
96 const type *src = (const type *)ssrc; \
97 type *dst = (type *)ddst; \
98 \
99 dlinesize /= sizeof(type); \
100 slinesize /= sizeof(type); \
101 \
102 for (int y = 0; y < h; y++) { \
103 for (int x = 0; x < w; x++) { \
104 dst[x] = av_clip(src[x], min, max); \
105 } \
106 \
107 dst += dlinesize; \
108 src += slinesize; \
109 } \
110 }
111
112 LIMITER(8, uint8_t)
113 LIMITER(16, uint16_t)
114
115 static int config_input(AVFilterLink *inlink)
116 {
117 AVFilterContext *ctx = inlink->dst;
118 LimiterContext *s = ctx->priv;
119 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
120 int depth, vsub, hsub, ret;
121
122 s->nb_planes = av_pix_fmt_count_planes(inlink->format);
123
124 if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
125 return ret;
126
127 depth = desc->comp[0].depth;
128 hsub = desc->log2_chroma_w;
129 vsub = desc->log2_chroma_h;
130 s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
131 s->height[0] = s->height[3] = inlink->h;
132 s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, hsub);
133 s->width[0] = s->width[3] = inlink->w;
134
135 s->max = FFMIN(s->max, (1 << depth) - 1);
136 s->min = FFMIN(s->min, (1 << depth) - 1);
137
138 if (depth == 8) {
139 s->dsp.limiter = limiter8;
140 } else {
141 s->dsp.limiter = limiter16;
142 }
143
144 #if ARCH_X86
145 ff_limiter_init_x86(&s->dsp, desc->comp[0].depth);
146 #endif
147
148 return 0;
149 }
150
151 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
152 {
153 LimiterContext *s = ctx->priv;
154 ThreadData *td = arg;
155 AVFrame *in = td->in;
156 AVFrame *out = td->out;
157 int p;
158
159 for (p = 0; p < s->nb_planes; p++) {
160 const int h = s->height[p];
161 const int slice_start = (h * jobnr) / nb_jobs;
162 const int slice_end = (h * (jobnr+1)) / nb_jobs;
163
164 if (!((1 << p) & s->planes)) {
165 if (out != in)
166 av_image_copy_plane(out->data[p] + slice_start * out->linesize[p],
167 out->linesize[p],
168 in->data[p] + slice_start * in->linesize[p],
169 in->linesize[p],
170 s->linesize[p], slice_end - slice_start);
171 continue;
172 }
173
174 s->dsp.limiter(in->data[p] + slice_start * in->linesize[p],
175 out->data[p] + slice_start * out->linesize[p],
176 in->linesize[p], out->linesize[p],
177 s->width[p], slice_end - slice_start,
178 s->min, s->max);
179 }
180
181 return 0;
182 }
183
184 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
185 {
186 AVFilterContext *ctx = inlink->dst;
187 LimiterContext *s = ctx->priv;
188 AVFilterLink *outlink = ctx->outputs[0];
189 ThreadData td;
190 AVFrame *out;
191
192 if (av_frame_is_writable(in)) {
193 out = in;
194 } else {
195 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
196 if (!out) {
197 av_frame_free(&in);
198 return AVERROR(ENOMEM);
199 }
200 av_frame_copy_props(out, in);
201 }
202
203 td.out = out;
204 td.in = in;
205 ff_filter_execute(ctx, filter_slice, &td, NULL,
206 FFMIN(s->height[2], ff_filter_get_nb_threads(ctx)));
207 if (out != in)
208 av_frame_free(&in);
209
210 return ff_filter_frame(outlink, out);
211 }
212
213 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
214 char *res, int res_len, int flags)
215 {
216 int ret;
217
218 ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
219 if (ret < 0)
220 return ret;
221
222 return config_input(ctx->inputs[0]);
223 }
224
225 static const AVFilterPad inputs[] = {
226 {
227 .name = "default",
228 .type = AVMEDIA_TYPE_VIDEO,
229 .filter_frame = filter_frame,
230 .config_props = config_input,
231 },
232 };
233
234 static const AVFilterPad outputs[] = {
235 {
236 .name = "default",
237 .type = AVMEDIA_TYPE_VIDEO,
238 },
239 };
240
241 const AVFilter ff_vf_limiter = {
242 .name = "limiter",
243 .description = NULL_IF_CONFIG_SMALL("Limit pixels components to the specified range."),
244 .priv_size = sizeof(LimiterContext),
245 .priv_class = &limiter_class,
246 .init = init,
247 FILTER_INPUTS(inputs),
248 FILTER_OUTPUTS(outputs),
249 FILTER_PIXFMTS_ARRAY(pix_fmts),
250 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
251 .process_command = process_command,
252 };
253