FFmpeg coverage


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