FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/vf_cover_rect.c
Date: 2024-04-27 00:58:15
Exec Total Coverage
Lines: 0 111 0.0%
Functions: 0 6 0.0%
Branches: 0 82 0.0%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2014-2015 Michael Niedermayer <michaelni@gmx.at>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (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
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 /**
22 * @todo switch to dualinput
23 */
24
25 #include "libavutil/mem.h"
26 #include "libavutil/opt.h"
27 #include "filters.h"
28 #include "internal.h"
29 #include "video.h"
30
31 #include "lavfutils.h"
32
33 enum mode {
34 MODE_COVER,
35 MODE_BLUR,
36 NB_MODES
37 };
38
39 typedef struct CoverContext {
40 AVClass *class;
41 int mode;
42 char *cover_filename;
43 AVFrame *cover_frame;
44 int width, height;
45 } CoverContext;
46
47 #define OFFSET(x) offsetof(CoverContext, x)
48 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
49 static const AVOption cover_rect_options[] = {
50 { "cover", "cover bitmap filename", OFFSET(cover_filename), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = FLAGS },
51 { "mode", "set removal mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = MODE_BLUR}, 0, NB_MODES - 1, FLAGS, .unit = "mode" },
52 { "cover", "cover area with bitmap", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_COVER}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
53 { "blur", "blur area", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_BLUR}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
54 { NULL }
55 };
56
57 AVFILTER_DEFINE_CLASS(cover_rect);
58
59 ✗ static int config_input(AVFilterLink *inlink)
60 {
61 ✗ return 0;
62 }
63
64 ✗ static void cover_rect(CoverContext *cover, AVFrame *in, int offx, int offy)
65 {
66 int x, y, p;
67
68 ✗ for (p = 0; p < 3; p++) {
69 ✗ uint8_t *data = in->data[p] + (offx>>!!p) + (offy>>!!p) * in->linesize[p];
70 ✗ const uint8_t *src = cover->cover_frame->data[p];
71 ✗ int w = AV_CEIL_RSHIFT(cover->cover_frame->width , !!p);
72 ✗ int h = AV_CEIL_RSHIFT(cover->cover_frame->height, !!p);
73 ✗ for (y = 0; y < h; y++) {
74 ✗ for (x = 0; x < w; x++) {
75 ✗ data[x] = src[x];
76 }
77 ✗ data += in->linesize[p];
78 ✗ src += cover->cover_frame->linesize[p];
79 }
80 }
81 ✗ }
82 ✗ static void blur(CoverContext *cover, AVFrame *in, int offx, int offy)
83 {
84 int x, y, p;
85
86 ✗ for (p=0; p<3; p++) {
87 ✗ int ox = offx>>!!p;
88 ✗ int oy = offy>>!!p;
89 ✗ int stride = in->linesize[p];
90 ✗ uint8_t *data = in->data[p] + ox + oy * stride;
91 ✗ int w = AV_CEIL_RSHIFT(cover->width , !!p);
92 ✗ int h = AV_CEIL_RSHIFT(cover->height, !!p);
93 ✗ int iw = AV_CEIL_RSHIFT(in->width , !!p);
94 ✗ int ih = AV_CEIL_RSHIFT(in->height, !!p);
95 ✗ for (y = 0; y < h; y++) {
96 ✗ for (x = 0; x < w; x++) {
97 ✗ int c = 0;
98 ✗ int s = 0;
99 ✗ if (ox) {
100 ✗ int scale = 65536 / (x + 1);
101 ✗ s += data[-1 + y*stride] * scale;
102 ✗ c += scale;
103 }
104 ✗ if (oy) {
105 ✗ int scale = 65536 / (y + 1);
106 ✗ s += data[x - stride] * scale;
107 ✗ c += scale;
108 }
109 ✗ if (ox + w < iw) {
110 ✗ int scale = 65536 / (w - x);
111 ✗ s += data[w + y*stride] * scale;
112 ✗ c += scale;
113 }
114 ✗ if (oy + h < ih) {
115 ✗ int scale = 65536 / (h - y);
116 ✗ s += data[x + h*stride] * scale;
117 ✗ c += scale;
118 }
119 ✗ data[x + y*stride] = c ? (s + (c>>1)) / c : 0;
120 }
121 }
122 }
123 ✗ }
124
125 ✗ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
126 {
127 ✗ AVFilterContext *ctx = inlink->dst;
128 ✗ CoverContext *cover = ctx->priv;
129 AVDictionaryEntry *ex, *ey, *ew, *eh;
130 ✗ int ret, x = -1, y = -1, w = -1, h = -1;
131 ✗ char *xendptr = NULL, *yendptr = NULL, *wendptr = NULL, *hendptr = NULL;
132
133 ✗ ex = av_dict_get(in->metadata, "lavfi.rect.x", NULL, AV_DICT_MATCH_CASE);
134 ✗ ey = av_dict_get(in->metadata, "lavfi.rect.y", NULL, AV_DICT_MATCH_CASE);
135 ✗ ew = av_dict_get(in->metadata, "lavfi.rect.w", NULL, AV_DICT_MATCH_CASE);
136 ✗ eh = av_dict_get(in->metadata, "lavfi.rect.h", NULL, AV_DICT_MATCH_CASE);
137 ✗ if (ex && ey && ew && eh) {
138 ✗ x = strtol(ex->value, &xendptr, 10);
139 ✗ y = strtol(ey->value, &yendptr, 10);
140 ✗ w = strtol(ew->value, &wendptr, 10);
141 ✗ h = strtol(eh->value, &hendptr, 10);
142 }
143
144 ✗ if (!xendptr || *xendptr || !yendptr || *yendptr ||
145 ✗ !wendptr || *wendptr || !hendptr || *hendptr
146 ) {
147 ✗ return ff_filter_frame(ctx->outputs[0], in);
148 }
149
150 ✗ if (x < 0) {
151 ✗ w += x;
152 ✗ x = 0;
153 }
154 ✗ if (y < 0) {
155 ✗ h += y;
156 ✗ y = 0;
157 }
158 ✗ w = FFMIN(w, in->width - x);
159 ✗ h = FFMIN(h, in->height - y);
160
161 ✗ if (w > in->width || h > in->height || w <= 0 || h <= 0)
162 ✗ return AVERROR(EINVAL);
163
164 ✗ if (cover->cover_frame) {
165 ✗ if (w != cover->cover_frame->width || h != cover->cover_frame->height)
166 ✗ return AVERROR(EINVAL);
167 }
168
169 ✗ cover->width = w;
170 ✗ cover->height = h;
171
172 ✗ x = av_clip(x, 0, in->width - w);
173 ✗ y = av_clip(y, 0, in->height - h);
174
175 ✗ ret = ff_inlink_make_frame_writable(inlink, &in);
176 ✗ if (ret < 0) {
177 ✗ av_frame_free(&in);
178 ✗ return ret;
179 }
180
181 ✗ if (cover->mode == MODE_BLUR) {
182 ✗ blur (cover, in, x, y);
183 } else {
184 ✗ cover_rect(cover, in, x, y);
185 }
186 ✗ return ff_filter_frame(ctx->outputs[0], in);
187 }
188
189 ✗ static av_cold void uninit(AVFilterContext *ctx)
190 {
191 ✗ CoverContext *cover = ctx->priv;
192
193 ✗ if (cover->cover_frame)
194 ✗ av_freep(&cover->cover_frame->data[0]);
195 ✗ av_frame_free(&cover->cover_frame);
196 ✗ }
197
198 ✗ static av_cold int init(AVFilterContext *ctx)
199 {
200 ✗ CoverContext *cover = ctx->priv;
201 int ret;
202
203 ✗ if (cover->mode == MODE_COVER) {
204 ✗ if (!cover->cover_filename) {
205 ✗ av_log(ctx, AV_LOG_ERROR, "cover filename not set\n");
206 ✗ return AVERROR(EINVAL);
207 }
208
209 ✗ cover->cover_frame = av_frame_alloc();
210 ✗ if (!cover->cover_frame)
211 ✗ return AVERROR(ENOMEM);
212
213 ✗ if ((ret = ff_load_image(cover->cover_frame->data, cover->cover_frame->linesize,
214 ✗ &cover->cover_frame->width, &cover->cover_frame->height,
215 ✗ &cover->cover_frame->format, cover->cover_filename, ctx)) < 0)
216 ✗ return ret;
217
218 ✗ if (cover->cover_frame->format != AV_PIX_FMT_YUV420P && cover->cover_frame->format != AV_PIX_FMT_YUVJ420P) {
219 ✗ av_log(ctx, AV_LOG_ERROR, "cover image is not a YUV420 image\n");
220 ✗ return AVERROR(EINVAL);
221 }
222 }
223
224 ✗ return 0;
225 }
226
227 static const AVFilterPad cover_rect_inputs[] = {
228 {
229 .name = "default",
230 .type = AVMEDIA_TYPE_VIDEO,
231 .config_props = config_input,
232 .filter_frame = filter_frame,
233 },
234 };
235
236 const AVFilter ff_vf_cover_rect = {
237 .name = "cover_rect",
238 .description = NULL_IF_CONFIG_SMALL("Find and cover a user specified object."),
239 .priv_size = sizeof(CoverContext),
240 .init = init,
241 .uninit = uninit,
242 FILTER_INPUTS(cover_rect_inputs),
243 FILTER_OUTPUTS(ff_video_default_filterpad),
244 FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
245 .priv_class = &cover_rect_class,
246 };
247