avfilter/vf_despill: fix assigment
[ffmpeg.git] / libavfilter / vf_floodfill.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/opt.h"
22 #include "libavutil/imgutils.h"
23 #include "libavutil/intreadwrite.h"
24 #include "avfilter.h"
25 #include "formats.h"
26 #include "internal.h"
27 #include "video.h"
28
29 typedef struct Points {
30     uint16_t x, y;
31 } Points;
32
33 typedef struct FloodfillContext {
34     const AVClass *class;
35
36     int x, y;
37     int s0, s1, s2, s3;
38     int d0, d1, d2, d3;
39
40     int back, front;
41     Points *points;
42
43     int (*is_same)(AVFrame *frame, int x, int y,
44                    unsigned s0, unsigned s1, unsigned s2, unsigned s3);
45     void (*set_pixel)(AVFrame *frame, int x, int y,
46                       unsigned d0, unsigned d1, unsigned d2, unsigned d3);
47     void (*pick_pixel)(AVFrame *frame, int x, int y,
48                        int *s0, int *s1, int *s2, int *s3);
49 } FloodfillContext;
50
51 static int is_inside(int x, int y, int w, int h)
52 {
53     if (x >= 0 && x < w && y >= 0 && y < h)
54         return 1;
55     return 0;
56 }
57
58 static int is_same4(AVFrame *frame, int x, int y,
59                     unsigned s0, unsigned s1, unsigned s2, unsigned s3)
60 {
61     unsigned c0 = frame->data[0][y * frame->linesize[0] + x];
62     unsigned c1 = frame->data[1][y * frame->linesize[1] + x];
63     unsigned c2 = frame->data[2][y * frame->linesize[2] + x];
64     unsigned c3 = frame->data[3][y * frame->linesize[3] + x];
65
66     if (s0 == c0 && s1 == c1 && s2 == c2 && s3 == c3)
67         return 1;
68     return 0;
69 }
70
71 static int is_same4_16(AVFrame *frame, int x, int y,
72                        unsigned s0, unsigned s1, unsigned s2, unsigned s3)
73 {
74     unsigned c0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
75     unsigned c1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
76     unsigned c2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
77     unsigned c3 = AV_RN16(frame->data[3] + y * frame->linesize[3] + 2 * x);
78
79     if (s0 == c0 && s1 == c1 && s2 == c2 && s3 == c3)
80         return 1;
81     return 0;
82 }
83
84 static int is_same3(AVFrame *frame, int x, int y,
85                     unsigned s0, unsigned s1, unsigned s2, unsigned s3)
86 {
87     unsigned c0 = frame->data[0][y * frame->linesize[0] + x];
88     unsigned c1 = frame->data[1][y * frame->linesize[1] + x];
89     unsigned c2 = frame->data[2][y * frame->linesize[2] + x];
90
91     if (s0 == c0 && s1 == c1 && s2 == c2)
92         return 1;
93     return 0;
94 }
95
96 static int is_same3_16(AVFrame *frame, int x, int y,
97                        unsigned s0, unsigned s1, unsigned s2, unsigned s3)
98 {
99     unsigned c0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
100     unsigned c1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
101     unsigned c2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
102
103     if (s0 == c0 && s1 == c1 && s2 == c2)
104         return 1;
105     return 0;
106 }
107
108 static int is_same1(AVFrame *frame, int x, int y,
109                     unsigned s0, unsigned s1, unsigned s2, unsigned s3)
110 {
111     unsigned c0 = frame->data[0][y * frame->linesize[0] + x];
112
113     if (s0 == c0)
114         return 1;
115     return 0;
116 }
117
118 static int is_same1_16(AVFrame *frame, int x, int y,
119                        unsigned s0, unsigned s1, unsigned s2, unsigned s3)
120 {
121     unsigned c0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
122
123     if (s0 == c0)
124         return 1;
125     return 0;
126 }
127
128 static void set_pixel1(AVFrame *frame, int x, int y,
129                        unsigned d0, unsigned d1, unsigned d2, unsigned d3)
130 {
131     frame->data[0][y * frame->linesize[0] + x] = d0;
132 }
133
134 static void set_pixel1_16(AVFrame *frame, int x, int y,
135                           unsigned d0, unsigned d1, unsigned d2, unsigned d3)
136 {
137     AV_WN16(frame->data[0] + y * frame->linesize[0] + 2 * x, d0);
138 }
139
140 static void set_pixel3(AVFrame *frame, int x, int y,
141                        unsigned d0, unsigned d1, unsigned d2, unsigned d3)
142 {
143     frame->data[0][y * frame->linesize[0] + x] = d0;
144     frame->data[1][y * frame->linesize[1] + x] = d1;
145     frame->data[2][y * frame->linesize[2] + x] = d2;
146 }
147
148 static void set_pixel3_16(AVFrame *frame, int x, int y,
149                           unsigned d0, unsigned d1, unsigned d2, unsigned d3)
150 {
151     AV_WN16(frame->data[0] + y * frame->linesize[0] + 2 * x, d0);
152     AV_WN16(frame->data[1] + y * frame->linesize[1] + 2 * x, d1);
153     AV_WN16(frame->data[2] + y * frame->linesize[2] + 2 * x, d2);
154 }
155
156 static void set_pixel4(AVFrame *frame, int x, int y,
157                        unsigned d0, unsigned d1, unsigned d2, unsigned d3)
158 {
159     frame->data[0][y * frame->linesize[0] + x] = d0;
160     frame->data[1][y * frame->linesize[1] + x] = d1;
161     frame->data[2][y * frame->linesize[2] + x] = d2;
162     frame->data[3][y * frame->linesize[3] + x] = d3;
163 }
164
165 static void set_pixel4_16(AVFrame *frame, int x, int y,
166                           unsigned d0, unsigned d1, unsigned d2, unsigned d3)
167 {
168     AV_WN16(frame->data[0] + y * frame->linesize[0] + 2 * x, d0);
169     AV_WN16(frame->data[1] + y * frame->linesize[1] + 2 * x, d1);
170     AV_WN16(frame->data[2] + y * frame->linesize[2] + 2 * x, d2);
171     AV_WN16(frame->data[3] + y * frame->linesize[3] + 2 * x, d3);
172 }
173
174 static void pick_pixel1(AVFrame *frame, int x, int y,
175                         int *s0, int *s1, int *s2, int *s3)
176 {
177     if (*s0 < 0)
178         *s0 = frame->data[0][y * frame->linesize[0] + x];
179 }
180
181 static void pick_pixel1_16(AVFrame *frame, int x, int y,
182                            int *s0, int *s1, int *s2, int *s3)
183 {
184     if (*s0 < 0)
185         *s0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
186 }
187
188 static void pick_pixel3(AVFrame *frame, int x, int y,
189                         int *s0, int *s1, int *s2, int *s3)
190 {
191     if (*s0 < 0)
192         *s0 = frame->data[0][y * frame->linesize[0] + x];
193     if (*s1 < 0)
194         *s1 = frame->data[1][y * frame->linesize[1] + x];
195     if (*s2 < 0)
196         *s2 = frame->data[2][y * frame->linesize[2] + x];
197 }
198
199 static void pick_pixel3_16(AVFrame *frame, int x, int y,
200                            int *s0, int *s1, int *s2, int *s3)
201 {
202     if (*s0 < 0)
203         *s0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
204     if (*s1 < 0)
205         *s1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
206     if (*s2 < 0)
207         *s2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
208 }
209
210 static void pick_pixel4(AVFrame *frame, int x, int y,
211                         int *s0, int *s1, int *s2, int *s3)
212 {
213     if (*s0 < 0)
214         *s0 = frame->data[0][y * frame->linesize[0] + x];
215     if (*s1 < 0)
216         *s1 = frame->data[1][y * frame->linesize[1] + x];
217     if (*s2 < 0)
218         *s2 = frame->data[2][y * frame->linesize[2] + x];
219     if (*s3 < 0)
220         *s3 = frame->data[3][y * frame->linesize[3] + x];
221 }
222
223 static void pick_pixel4_16(AVFrame *frame, int x, int y,
224                            int *s0, int *s1, int *s2, int *s3)
225 {
226     if (*s0 < 0)
227         *s0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
228     if (*s1 < 0)
229         *s1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
230     if (*s2 < 0)
231         *s2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
232     if (*s3 < 0)
233         *s3 = AV_RN16(frame->data[3] + y * frame->linesize[3] + 2 * x);
234 }
235
236 static int config_input(AVFilterLink *inlink)
237 {
238     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
239     AVFilterContext *ctx = inlink->dst;
240     FloodfillContext *s = ctx->priv;
241     int nb_planes = av_pix_fmt_count_planes(inlink->format);
242     int depth;
243
244     depth = desc->comp[0].depth;
245     if (depth == 8) {
246         switch (nb_planes) {
247         case 1: s->set_pixel  = set_pixel1;
248                 s->is_same    = is_same1;
249                 s->pick_pixel = pick_pixel1; break;
250         case 3: s->set_pixel  = set_pixel3;
251                 s->is_same    = is_same3;
252                 s->pick_pixel = pick_pixel3; break;
253         case 4: s->set_pixel  = set_pixel4;
254                 s->is_same    = is_same4;
255                 s->pick_pixel = pick_pixel4; break;
256        }
257     } else {
258         switch (nb_planes) {
259         case 1: s->set_pixel  = set_pixel1_16;
260                 s->is_same    = is_same1_16;
261                 s->pick_pixel = pick_pixel1_16; break;
262         case 3: s->set_pixel  = set_pixel3_16;
263                 s->is_same    = is_same3_16;
264                 s->pick_pixel = pick_pixel3_16; break;
265         case 4: s->set_pixel  = set_pixel4_16;
266                 s->is_same    = is_same4_16;
267                 s->pick_pixel = pick_pixel4_16; break;
268        }
269     }
270
271     s->front = s->back = 0;
272     s->points = av_calloc(inlink->w * inlink->h, 4 * sizeof(Points));
273     if (!s->points)
274         return AVERROR(ENOMEM);
275
276     return 0;
277 }
278
279 static int filter_frame(AVFilterLink *link, AVFrame *frame)
280 {
281     AVFilterContext *ctx = link->dst;
282     FloodfillContext *s = ctx->priv;
283     const unsigned d0 = s->d0;
284     const unsigned d1 = s->d1;
285     const unsigned d2 = s->d2;
286     const unsigned d3 = s->d3;
287     int s0 = s->s0;
288     int s1 = s->s1;
289     int s2 = s->s2;
290     int s3 = s->s3;
291     const int w = frame->width;
292     const int h = frame->height;
293     int ret;
294
295     if (ret = av_frame_make_writable(frame))
296         return ret;
297
298     if (is_inside(s->x, s->y, w, h)) {
299         s->pick_pixel(frame, s->x, s->y, &s0, &s1, &s2, &s3);
300
301         if (s->is_same(frame, s->x, s->y, s0, s1, s2, s3)) {
302             s->points[s->front].x = s->x;
303             s->points[s->front].y = s->y;
304             s->front++;
305         }
306
307         while (s->front > s->back) {
308             int x, y;
309
310             s->front--;
311             x = s->points[s->front].x;
312             y = s->points[s->front].y;
313
314             if (s->is_same(frame, x, y, s0, s1, s2, s3)) {
315                 s->set_pixel(frame, x, y, d0, d1, d2, d3);
316
317                 if (is_inside(x + 1, y, w, h)) {
318                     s->points[s->front]  .x = x + 1;
319                     s->points[s->front++].y = y;
320                 }
321
322                 if (is_inside(x - 1, y, w, h)) {
323                     s->points[s->front]  .x = x - 1;
324                     s->points[s->front++].y = y;
325                 }
326
327                 if (is_inside(x, y + 1, w, h)) {
328                     s->points[s->front]  .x = x;
329                     s->points[s->front++].y = y + 1;
330                 }
331
332                 if (is_inside(x, y - 1, w, h)) {
333                     s->points[s->front]  .x = x;
334                     s->points[s->front++].y = y - 1;
335                 }
336             }
337         }
338     }
339
340     return ff_filter_frame(ctx->outputs[0], frame);
341 }
342
343 static av_cold int query_formats(AVFilterContext *ctx)
344 {
345     static const enum AVPixelFormat pixel_fmts[] = {
346         AV_PIX_FMT_GRAY8,
347         AV_PIX_FMT_YUV444P,
348         AV_PIX_FMT_YUVA444P,
349         AV_PIX_FMT_GBRP,
350         AV_PIX_FMT_GBRP9,
351         AV_PIX_FMT_GBRP10,
352         AV_PIX_FMT_GBRAP10,
353         AV_PIX_FMT_GBRP12,
354         AV_PIX_FMT_GBRAP12,
355         AV_PIX_FMT_GBRP14,
356         AV_PIX_FMT_GBRP16,
357         AV_PIX_FMT_GBRAP16,
358         AV_PIX_FMT_GBRAP,
359         AV_PIX_FMT_YUV444P9,
360         AV_PIX_FMT_YUVA444P9,
361         AV_PIX_FMT_YUV444P10,
362         AV_PIX_FMT_YUVA444P10,
363         AV_PIX_FMT_YUV444P12,
364         AV_PIX_FMT_YUV444P14,
365         AV_PIX_FMT_GRAY16,
366         AV_PIX_FMT_YUV444P16,
367         AV_PIX_FMT_YUVA444P16,
368         AV_PIX_FMT_NONE
369     };
370     AVFilterFormats *formats;
371
372     formats = ff_make_format_list(pixel_fmts);
373     if (!formats)
374         return AVERROR(ENOMEM);
375
376     return ff_set_common_formats(ctx, formats);
377 }
378
379 static av_cold void uninit(AVFilterContext *ctx)
380 {
381     FloodfillContext *s = ctx->priv;
382
383     av_freep(&s->points);
384 }
385
386 static const AVFilterPad floodfill_inputs[] = {
387     {
388         .name         = "default",
389         .type         = AVMEDIA_TYPE_VIDEO,
390         .filter_frame = filter_frame,
391         .config_props = config_input,
392     },
393     { NULL }
394 };
395
396 static const AVFilterPad floodfill_outputs[] = {
397     {
398         .name = "default",
399         .type = AVMEDIA_TYPE_VIDEO,
400     },
401     { NULL }
402 };
403
404 #define OFFSET(x) offsetof(FloodfillContext, x)
405 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
406
407 static const AVOption floodfill_options[] = {
408     { "x",  "set pixel x coordinate",             OFFSET(x),  AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
409     { "y",  "set pixel y coordinate",             OFFSET(y),  AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
410     { "s0", "set source #0 component value",      OFFSET(s0), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
411     { "s1", "set source #1 component value",      OFFSET(s1), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
412     { "s2", "set source #2 component value",      OFFSET(s2), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
413     { "s3", "set source #3 component value",      OFFSET(s3), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
414     { "d0", "set destination #0 component value", OFFSET(d0), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
415     { "d1", "set destination #1 component value", OFFSET(d1), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
416     { "d2", "set destination #2 component value", OFFSET(d2), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
417     { "d3", "set destination #3 component value", OFFSET(d3), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
418     { NULL }
419 };
420
421 AVFILTER_DEFINE_CLASS(floodfill);
422
423 AVFilter ff_vf_floodfill = {
424     .name          = "floodfill",
425     .description   = NULL_IF_CONFIG_SMALL("Fill area with same color with another color."),
426     .priv_size     = sizeof(FloodfillContext),
427     .priv_class    = &floodfill_class,
428     .query_formats = query_formats,
429     .uninit        = uninit,
430     .inputs        = floodfill_inputs,
431     .outputs       = floodfill_outputs,
432     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
433 };