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