FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_cover_rect.c
Date: 2024-04-12 08:31:17
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