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