avfilter: add fillborders filter
[ffmpeg.git] / libavfilter / vf_fillborders.c
1 /*
2  * Copyright (c) 2017 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (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 GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "libavutil/colorspace.h"
22 #include "libavutil/common.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/pixdesc.h"
25 #include "avfilter.h"
26 #include "drawutils.h"
27 #include "formats.h"
28 #include "internal.h"
29 #include "video.h"
30
31 enum { Y, U, V, A };
32 enum { R, G, B };
33
34 enum FillMode { FM_SMEAR, FM_MIRROR, FM_FIXED, FM_NB_MODES };
35
36 typedef struct Borders {
37     int left, right, top, bottom;
38 } Borders;
39
40 typedef struct FillBordersContext {
41     const AVClass *class;
42     int left, right, top, bottom;
43     int mode;
44
45     int nb_planes;
46     int depth;
47     Borders borders[4];
48     int planewidth[4];
49     int planeheight[4];
50     uint8_t fill[4];
51     uint8_t yuv_color[4];
52     uint8_t rgba_color[4];
53
54     void (*fillborders)(struct FillBordersContext *s, AVFrame *frame);
55 } FillBordersContext;
56
57 static int query_formats(AVFilterContext *ctx)
58 {
59     static const enum AVPixelFormat pix_fmts[] = {
60         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
61         AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
62         AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
63         AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
64         AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
65         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
66         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
67         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
68         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
69         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
70         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
71         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
72         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
73         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
74         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
75         AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
76         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
77         AV_PIX_FMT_NONE
78     };
79     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
80     if (!fmts_list)
81         return AVERROR(ENOMEM);
82     return ff_set_common_formats(ctx, fmts_list);
83 }
84
85 static void smear_borders8(FillBordersContext *s, AVFrame *frame)
86 {
87     int p, y;
88
89     for (p = 0; p < s->nb_planes; p++) {
90         uint8_t *ptr = frame->data[p];
91         int linesize = frame->linesize[p];
92
93         for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) {
94             memset(ptr + y * linesize,
95                    *(ptr + y * linesize + s->borders[p].left),
96                    s->borders[p].left);
97             memset(ptr + y * linesize + s->planewidth[p] - s->borders[p].right,
98                    *(ptr + y * linesize + s->planewidth[p] - s->borders[p].right - 1),
99                    s->borders[p].right);
100         }
101
102         for (y = 0; y < s->borders[p].top; y++) {
103             memcpy(ptr + y * linesize,
104                    ptr + s->borders[p].top * linesize, s->planewidth[p]);
105         }
106
107         for (y = s->planeheight[p] - s->borders[p].bottom; y < s->planeheight[p]; y++) {
108             memcpy(ptr + y * linesize,
109                    ptr + (s->planeheight[p] - s->borders[p].bottom - 1) * linesize,
110                    s->planewidth[p]);
111         }
112     }
113 }
114
115 static void smear_borders16(FillBordersContext *s, AVFrame *frame)
116 {
117     int p, y, x;
118
119     for (p = 0; p < s->nb_planes; p++) {
120         uint16_t *ptr = (uint16_t *)frame->data[p];
121         int linesize = frame->linesize[p] / 2;
122
123         for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) {
124             for (x = 0; x < s->borders[p].left; x++) {
125                 ptr[y * linesize + x] =  *(ptr + y * linesize + s->borders[p].left);
126             }
127
128             for (x = 0; x < s->borders[p].right; x++) {
129                 ptr[y * linesize + s->planewidth[p] - s->borders[p].right + x] =
130                    *(ptr + y * linesize + s->planewidth[p] - s->borders[p].right - 1);
131             }
132         }
133
134         for (y = 0; y < s->borders[p].top; y++) {
135             memcpy(ptr + y * linesize,
136                    ptr + s->borders[p].top * linesize, s->planewidth[p] * 2);
137         }
138
139         for (y = s->planeheight[p] - s->borders[p].bottom; y < s->planeheight[p]; y++) {
140             memcpy(ptr + y * linesize,
141                    ptr + (s->planeheight[p] - s->borders[p].bottom - 1) * linesize,
142                    s->planewidth[p] * 2);
143         }
144     }
145 }
146
147 static void mirror_borders8(FillBordersContext *s, AVFrame *frame)
148 {
149     int p, y, x;
150
151     for (p = 0; p < s->nb_planes; p++) {
152         uint8_t *ptr = frame->data[p];
153         int linesize = frame->linesize[p];
154
155         for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) {
156             for (x = 0; x < s->borders[p].left; x++) {
157                 ptr[y * linesize + x] = ptr[y * linesize + s->borders[p].left * 2 - 1 - x];
158             }
159
160             for (x = 0; x < s->borders[p].right; x++) {
161                 ptr[y * linesize + s->planewidth[p] - s->borders[p].right + x] =
162                     ptr[y * linesize + s->planewidth[p] - s->borders[p].right - 1 - x];
163             }
164         }
165
166         for (y = 0; y < s->borders[p].top; y++) {
167             memcpy(ptr + y * linesize,
168                    ptr + (s->borders[p].top * 2 - 1 - y) * linesize,
169                    s->planewidth[p]);
170         }
171
172         for (y = 0; y < s->borders[p].bottom; y++) {
173             memcpy(ptr + (s->planeheight[p] - s->borders[p].bottom + y) * linesize,
174                    ptr + (s->planeheight[p] - s->borders[p].bottom - 1 - y) * linesize,
175                    s->planewidth[p]);
176         }
177     }
178 }
179
180 static void mirror_borders16(FillBordersContext *s, AVFrame *frame)
181 {
182     int p, y, x;
183
184     for (p = 0; p < s->nb_planes; p++) {
185         uint16_t *ptr = (uint16_t *)frame->data[p];
186         int linesize = frame->linesize[p] / 2;
187
188         for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) {
189             for (x = 0; x < s->borders[p].left; x++) {
190                 ptr[y * linesize + x] = ptr[y * linesize + s->borders[p].left * 2 - 1 - x];
191             }
192
193             for (x = 0; x < s->borders[p].right; x++) {
194                 ptr[y * linesize + s->planewidth[p] - s->borders[p].right + x] =
195                     ptr[y * linesize + s->planewidth[p] - s->borders[p].right - 1 - x];
196             }
197         }
198
199         for (y = 0; y < s->borders[p].top; y++) {
200             memcpy(ptr + y * linesize,
201                    ptr + (s->borders[p].top * 2 - 1 - y) * linesize,
202                    s->planewidth[p] * 2);
203         }
204
205         for (y = 0; y < s->borders[p].bottom; y++) {
206             memcpy(ptr + (s->planeheight[p] - s->borders[p].bottom + y) * linesize,
207                    ptr + (s->planeheight[p] - s->borders[p].bottom - 1 - y) * linesize,
208                    s->planewidth[p] * 2);
209         }
210     }
211 }
212
213 static void fixed_borders8(FillBordersContext *s, AVFrame *frame)
214 {
215     int p, y;
216
217     for (p = 0; p < s->nb_planes; p++) {
218         uint8_t *ptr = frame->data[p];
219         uint8_t fill = s->fill[p];
220         int linesize = frame->linesize[p];
221
222         for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) {
223             memset(ptr + y * linesize, fill, s->borders[p].left);
224             memset(ptr + y * linesize + s->planewidth[p] - s->borders[p].right, fill,
225                    s->borders[p].right);
226         }
227
228         for (y = 0; y < s->borders[p].top; y++) {
229             memset(ptr + y * linesize, fill, s->planewidth[p]);
230         }
231
232         for (y = s->planeheight[p] - s->borders[p].bottom; y < s->planeheight[p]; y++) {
233             memset(ptr + y * linesize, fill, s->planewidth[p]);
234         }
235     }
236 }
237
238 static void fixed_borders16(FillBordersContext *s, AVFrame *frame)
239 {
240     int p, y, x;
241
242     for (p = 0; p < s->nb_planes; p++) {
243         uint16_t *ptr = (uint16_t *)frame->data[p];
244         uint16_t fill = s->fill[p] << (s->depth - 8);
245         int linesize = frame->linesize[p] / 2;
246
247         for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) {
248             for (x = 0; x < s->borders[p].left; x++) {
249                 ptr[y * linesize + x] = fill;
250             }
251
252             for (x = 0; x < s->borders[p].right; x++) {
253                 ptr[y * linesize + s->planewidth[p] - s->borders[p].right + x] = fill;
254             }
255         }
256
257         for (y = 0; y < s->borders[p].top; y++) {
258             for (x = 0; x < s->planewidth[p]; x++) {
259                 ptr[y * linesize + x] = fill;
260             }
261         }
262
263         for (y = s->planeheight[p] - s->borders[p].bottom; y < s->planeheight[p]; y++) {
264             for (x = 0; x < s->planewidth[p]; x++) {
265                 ptr[y * linesize + x] = fill;
266             }
267         }
268     }
269 }
270
271 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
272 {
273     FillBordersContext *s = inlink->dst->priv;
274
275     s->fillborders(s, frame);
276
277     return ff_filter_frame(inlink->dst->outputs[0], frame);
278 }
279
280 static int config_input(AVFilterLink *inlink)
281 {
282     AVFilterContext *ctx = inlink->dst;
283     FillBordersContext *s = ctx->priv;
284     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
285
286     s->nb_planes = desc->nb_components;
287     s->depth = desc->comp[0].depth;
288
289     s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
290     s->planeheight[0] = s->planeheight[3] = inlink->h;
291     s->planewidth[1]  = s->planewidth[2]  = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
292     s->planewidth[0]  = s->planewidth[3]  = inlink->w;
293
294     s->borders[0].left   = s->borders[3].left = s->left;
295     s->borders[0].right  = s->borders[3].right = s->right;
296     s->borders[0].top    = s->borders[3].top = s->top;
297     s->borders[0].bottom = s->borders[3].bottom = s->bottom;
298
299     s->borders[1].left   = s->left >> desc->log2_chroma_w;
300     s->borders[1].right  = s->right >> desc->log2_chroma_w;
301     s->borders[1].top    = s->top >> desc->log2_chroma_h;
302     s->borders[1].bottom = s->bottom >> desc->log2_chroma_h;
303
304     s->borders[2].left   = s->left >> desc->log2_chroma_w;
305     s->borders[2].right  = s->right >> desc->log2_chroma_w;
306     s->borders[2].top    = s->top >> desc->log2_chroma_h;
307     s->borders[2].bottom = s->bottom >> desc->log2_chroma_h;
308
309     if (inlink->w < s->left + s->right ||
310         inlink->w <= s->left ||
311         inlink->w <= s->right ||
312         inlink->h < s->top + s->bottom ||
313         inlink->h <= s->top ||
314         inlink->h <= s->bottom ||
315         inlink->w < s->left * 2 ||
316         inlink->w < s->right * 2 ||
317         inlink->h < s->top * 2 ||
318         inlink->h < s->bottom * 2) {
319         av_log(ctx, AV_LOG_ERROR, "Borders are bigger than input frame size.\n");
320         return AVERROR(EINVAL);
321     }
322
323     switch (s->mode) {
324     case FM_SMEAR:  s->fillborders = s->depth <= 8 ? smear_borders8  : smear_borders16;  break;
325     case FM_MIRROR: s->fillborders = s->depth <= 8 ? mirror_borders8 : mirror_borders16; break;
326     case FM_FIXED:  s->fillborders = s->depth <= 8 ? fixed_borders8  : fixed_borders16;  break;
327     }
328
329     s->yuv_color[Y] = RGB_TO_Y_CCIR(s->rgba_color[R], s->rgba_color[G], s->rgba_color[B]);
330     s->yuv_color[U] = RGB_TO_U_CCIR(s->rgba_color[R], s->rgba_color[G], s->rgba_color[B], 0);
331     s->yuv_color[V] = RGB_TO_V_CCIR(s->rgba_color[R], s->rgba_color[G], s->rgba_color[B], 0);
332     s->yuv_color[A] = s->rgba_color[A];
333
334     if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
335         uint8_t rgba_map[4];
336         int i;
337
338         ff_fill_rgba_map(rgba_map, inlink->format);
339         for (i = 0; i < 4; i++)
340             s->fill[rgba_map[i]] = s->rgba_color[i];
341     } else {
342         memcpy(s->fill, s->yuv_color, sizeof(s->yuv_color));
343     }
344
345     return 0;
346 }
347
348 #define OFFSET(x) offsetof(FillBordersContext, x)
349 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
350
351 static const AVOption fillborders_options[] = {
352     { "left",   "set the left fill border",   OFFSET(left),   AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX,    FLAGS },
353     { "right",  "set the right fill border",  OFFSET(right),  AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX,    FLAGS },
354     { "top",    "set the top fill border",    OFFSET(top),    AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX,    FLAGS },
355     { "bottom", "set the bottom fill border", OFFSET(bottom), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX,    FLAGS },
356     { "mode",   "set the fill borders mode",  OFFSET(mode),   AV_OPT_TYPE_INT, {.i64=FM_SMEAR}, 0, FM_NB_MODES-1, FLAGS, "mode" },
357         { "smear",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=FM_SMEAR},  0, 0, FLAGS, "mode" },
358         { "mirror", NULL, 0, AV_OPT_TYPE_CONST, {.i64=FM_MIRROR}, 0, 0, FLAGS, "mode" },
359         { "fixed",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=FM_FIXED},  0, 0, FLAGS, "mode" },
360     { "color",  "set the color for the fixed mode", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str = "black"}, .flags = FLAGS },
361     { NULL }
362 };
363
364 AVFILTER_DEFINE_CLASS(fillborders);
365
366 static const AVFilterPad fillborders_inputs[] = {
367     {
368         .name           = "default",
369         .type           = AVMEDIA_TYPE_VIDEO,
370         .config_props   = config_input,
371         .filter_frame   = filter_frame,
372         .needs_writable = 1,
373     },
374     { NULL }
375 };
376
377 static const AVFilterPad fillborders_outputs[] = {
378     {
379         .name = "default",
380         .type = AVMEDIA_TYPE_VIDEO,
381     },
382     { NULL }
383 };
384
385 AVFilter ff_vf_fillborders = {
386     .name          = "fillborders",
387     .description   = NULL_IF_CONFIG_SMALL("Fill borders of the input video."),
388     .priv_size     = sizeof(FillBordersContext),
389     .priv_class    = &fillborders_class,
390     .query_formats = query_formats,
391     .inputs        = fillborders_inputs,
392     .outputs       = fillborders_outputs,
393     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
394 };