LICENSE.md: add *_rect filters
[ffmpeg.git] / libavfilter / vf_cover_rect.c
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
32 enum mode {
33     MODE_COVER,
34     MODE_BLUR,
35     NB_MODES
36 };
37
38 typedef 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
48 static 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
56 static const AVClass cover_rect_class = {
57     .class_name       = "cover_rect",
58     .item_name        = av_default_item_name,
59     .option           = cover_rect_options,
60     .version          = LIBAVUTIL_VERSION_INT,
61     .category         = AV_CLASS_CATEGORY_FILTER,
62 };
63
64 static int query_formats(AVFilterContext *ctx)
65 {
66     static const enum AVPixelFormat pix_fmts[] = {
67         AV_PIX_FMT_YUV420P,
68         AV_PIX_FMT_YUVJ420P,
69         AV_PIX_FMT_NONE
70     };
71
72     return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
73 }
74
75 static int config_input(AVFilterLink *inlink)
76 {
77     return 0;
78 }
79
80 static void cover_rect(CoverContext *cover, AVFrame *in, int offx, int offy)
81 {
82     int x, y, p;
83
84     for (p = 0; p < 3; p++) {
85         uint8_t *data = in->data[p] + (offx>>!!p) + (offy>>!!p) * in->linesize[p];
86         const uint8_t *src = cover->cover_frame->data[p];
87         int w = FF_CEIL_RSHIFT(cover->cover_frame->width , !!p);
88         int h = FF_CEIL_RSHIFT(cover->cover_frame->height, !!p);
89         for (y = 0; y < h; y++) {
90             for (x = 0; x < w; x++) {
91                 data[x] = src[x];
92             }
93             data += in->linesize[p];
94             src += cover->cover_frame->linesize[p];
95         }
96     }
97 }
98 static void blur(CoverContext *cover, AVFrame *in, int offx, int offy)
99 {
100     int x, y, p;
101
102     for (p=0; p<3; p++) {
103         int ox = offx>>!!p;
104         int oy = offy>>!!p;
105         int stride = in->linesize[p];
106         uint8_t *data = in->data[p] + ox + oy * stride;
107         int w = FF_CEIL_RSHIFT(cover->width , !!p);
108         int h = FF_CEIL_RSHIFT(cover->height, !!p);
109         int iw = FF_CEIL_RSHIFT(in->width , !!p);
110         int ih = FF_CEIL_RSHIFT(in->height, !!p);
111         for (y = 0; y < h; y++) {
112             for (x = 0; x < w; x++) {
113                 int c = 0;
114                 int s = 0;
115                 if (ox) {
116                     int scale = 65536 / (x + 1);
117                     s += data[-1 + y*stride] * scale;
118                     c += scale;
119                 }
120                 if (oy) {
121                     int scale = 65536 / (y + 1);
122                     s += data[x - stride] * scale;
123                     c += scale;
124                 }
125                 if (ox + w < iw) {
126                     int scale = 65536 / (w - x);
127                     s += data[w + y*stride] * scale;
128                     c += scale;
129                 }
130                 if (oy + h < ih) {
131                     int scale = 65536 / (h - y);
132                     s += data[x + h*stride] * scale;
133                     c += scale;
134                 }
135                 data[x + y*stride] = (s + (c>>1)) / c;
136             }
137         }
138     }
139 }
140
141 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
142 {
143     AVFilterContext *ctx = inlink->dst;
144     CoverContext *cover = ctx->priv;
145     AVDictionaryEntry *ex, *ey, *ew, *eh;
146     int x = -1, y = -1, w = -1, h = -1;
147     char *xendptr = NULL, *yendptr = NULL, *wendptr = NULL, *hendptr = NULL;
148
149     ex = av_dict_get(in->metadata, "lavfi.rect.x", NULL, AV_DICT_MATCH_CASE);
150     ey = av_dict_get(in->metadata, "lavfi.rect.y", NULL, AV_DICT_MATCH_CASE);
151     ew = av_dict_get(in->metadata, "lavfi.rect.w", NULL, AV_DICT_MATCH_CASE);
152     eh = av_dict_get(in->metadata, "lavfi.rect.h", NULL, AV_DICT_MATCH_CASE);
153     if (ex && ey && ew && eh) {
154         x = strtol(ex->value, &xendptr, 10);
155         y = strtol(ey->value, &yendptr, 10);
156         w = strtol(ew->value, &wendptr, 10);
157         h = strtol(eh->value, &hendptr, 10);
158     }
159
160     if (!xendptr || *xendptr || !yendptr || *yendptr ||
161         !wendptr || *wendptr || !hendptr || !hendptr
162     ) {
163         return ff_filter_frame(ctx->outputs[0], in);
164     }
165
166     if (w > in->width || h > in->height || w <= 0 || h <= 0)
167         return AVERROR(EINVAL);
168
169     if (cover->cover_frame) {
170         if (w != cover->cover_frame->width || h != cover->cover_frame->height)
171             return AVERROR(EINVAL);
172     }
173
174     cover->width  = w;
175     cover->height = h;
176
177     x = av_clip(x, 0, in->width  - w);
178     y = av_clip(y, 0, in->height - h);
179
180     av_frame_make_writable(in);
181
182     if (cover->mode == MODE_BLUR) {
183         blur (cover, in, x, y);
184     } else {
185         cover_rect(cover, in, x, y);
186     }
187     return ff_filter_frame(ctx->outputs[0], in);
188 }
189
190 static av_cold void uninit(AVFilterContext *ctx)
191 {
192     CoverContext *cover = ctx->priv;
193
194     if (cover->cover_frame)
195         av_freep(&cover->cover_frame->data[0]);
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     { NULL }
235 };
236
237 static const AVFilterPad cover_rect_outputs[] = {
238     {
239         .name = "default",
240         .type = AVMEDIA_TYPE_VIDEO,
241     },
242     { NULL }
243 };
244
245 AVFilter ff_vf_cover_rect = {
246     .name            = "cover_rect",
247     .description     = NULL_IF_CONFIG_SMALL("Find and cover a user specified object"),
248     .priv_size       = sizeof(CoverContext),
249     .init            = init,
250     .uninit          = uninit,
251     .query_formats   = query_formats,
252     .inputs          = cover_rect_inputs,
253     .outputs         = cover_rect_outputs,
254     .priv_class      = &cover_rect_class,
255 };