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