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/mem.h"
  26 #include "libavutil/opt.h"
  27 #include "filters.h"
  28 #include "video.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, .unit = "mode" },
  51         { "cover", "cover area with bitmap", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_COVER}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
  52         { "blur", "blur area", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_BLUR}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
  53     { NULL }
  54 };
  55
  56 AVFILTER_DEFINE_CLASS(cover_rect);
  57
  58 static int config_input(AVFilterLink *inlink)
  59 {
  60     return 0;
  61 }
  62
  63 static void cover_rect(CoverContext *cover, AVFrame *in, int offx, int offy)
  64 {
  65     int x, y, p;
  66
  67     for (p = 0; p < 3; p++) {
  68         uint8_t *data = in->data[p] + (offx>>!!p) + (offy>>!!p) * in->linesize[p];
  69         const uint8_t *src = cover->cover_frame->data[p];
  70         int w = AV_CEIL_RSHIFT(cover->cover_frame->width , !!p);
  71         int h = AV_CEIL_RSHIFT(cover->cover_frame->height, !!p);
  72         for (y = 0; y < h; y++) {
  73             for (x = 0; x < w; x++) {
  74                 data[x] = src[x];
  75             }
  76             data += in->linesize[p];
  77             src += cover->cover_frame->linesize[p];
  78         }
  79     }
  80 }
  81 static void blur(CoverContext *cover, AVFrame *in, int offx, int offy)
  82 {
  83     int x, y, p;
  84
  85     for (p=0; p<3; p++) {
  86         int ox = offx>>!!p;
  87         int oy = offy>>!!p;
  88         int stride = in->linesize[p];
  89         uint8_t *data = in->data[p] + ox + oy * stride;
  90         int w = AV_CEIL_RSHIFT(cover->width , !!p);
  91         int h = AV_CEIL_RSHIFT(cover->height, !!p);
  92         int iw = AV_CEIL_RSHIFT(in->width , !!p);
  93         int ih = AV_CEIL_RSHIFT(in->height, !!p);
  94         for (y = 0; y < h; y++) {
  95             for (x = 0; x < w; x++) {
  96                 int c = 0;
  97                 int s = 0;
  98                 if (ox) {
  99                     int scale = 65536 / (x + 1);
 100                     s += data[-1 + y*stride] * scale;
 101                     c += scale;
 102                 }
 103                 if (oy) {
 104                     int scale = 65536 / (y + 1);
 105                     s += data[x - stride] * scale;
 106                     c += scale;
 107                 }
 108                 if (ox + w < iw) {
 109                     int scale = 65536 / (w - x);
 110                     s += data[w + y*stride] * scale;
 111                     c += scale;
 112                 }
 113                 if (oy + h < ih) {
 114                     int scale = 65536 / (h - y);
 115                     s += data[x + h*stride] * scale;
 116                     c += scale;
 117                 }
 118                 data[x + y*stride] = c ? (s + (c>>1)) / c : 0;
 119             }
 120         }
 121     }
 122 }
 123
 124 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 125 {
 126     AVFilterContext *ctx = inlink->dst;
 127     CoverContext *cover = ctx->priv;
 128     AVDictionaryEntry *ex, *ey, *ew, *eh;
 129     int ret, x = -1, y = -1, w = -1, h = -1;
 130     char *xendptr = NULL, *yendptr = NULL, *wendptr = NULL, *hendptr = NULL;
 131
 132     ex = av_dict_get(in->metadata, "lavfi.rect.x", NULL, AV_DICT_MATCH_CASE);
 133     ey = av_dict_get(in->metadata, "lavfi.rect.y", NULL, AV_DICT_MATCH_CASE);
 134     ew = av_dict_get(in->metadata, "lavfi.rect.w", NULL, AV_DICT_MATCH_CASE);
 135     eh = av_dict_get(in->metadata, "lavfi.rect.h", NULL, AV_DICT_MATCH_CASE);
 136     if (ex && ey && ew && eh) {
 137         x = strtol(ex->value, &xendptr, 10);
 138         y = strtol(ey->value, &yendptr, 10);
 139         w = strtol(ew->value, &wendptr, 10);
 140         h = strtol(eh->value, &hendptr, 10);
 141     }
 142
 143     if (!xendptr || *xendptr || !yendptr || *yendptr ||
 144         !wendptr || *wendptr || !hendptr || *hendptr
 145     ) {
 146         return ff_filter_frame(ctx->outputs[0], in);
 147     }
 148
 149     if (x < 0) {
 150         w += x;
 151         x = 0;
 152     }
 153     if (y < 0) {
 154         h += y;
 155         y = 0;
 156     }
 157     w = FFMIN(w, in->width  - x);
 158     h = FFMIN(h, in->height - y);
 159
 160     if (w > in->width || h > in->height || w <= 0 || h <= 0)
 161         return AVERROR(EINVAL);
 162
 163     if (cover->cover_frame) {
 164         if (w != cover->cover_frame->width || h != cover->cover_frame->height)
 165             return AVERROR(EINVAL);
 166     }
 167
 168     cover->width  = w;
 169     cover->height = h;
 170
 171     x = av_clip(x, 0, in->width  - w);
 172     y = av_clip(y, 0, in->height - h);
 173
 174     ret = ff_inlink_make_frame_writable(inlink, &in);
 175     if (ret < 0) {
 176         av_frame_free(&in);
 177         return ret;
 178     }
 179
 180     if (cover->mode == MODE_BLUR) {
 181         blur (cover, in, x, y);
 182     } else {
 183         cover_rect(cover, in, x, y);
 184     }
 185     return ff_filter_frame(ctx->outputs[0], in);
 186 }
 187
 188 static av_cold void uninit(AVFilterContext *ctx)
 189 {
 190     CoverContext *cover = ctx->priv;
 191
 192     if (cover->cover_frame)
 193         av_freep(&cover->cover_frame->data[0]);
 194     av_frame_free(&cover->cover_frame);
 195 }
 196
 197 static av_cold int init(AVFilterContext *ctx)
 198 {
 199     CoverContext *cover = ctx->priv;
 200     int ret;
 201
 202     if (cover->mode == MODE_COVER) {
 203         if (!cover->cover_filename) {
 204             av_log(ctx, AV_LOG_ERROR, "cover filename not set\n");
 205             return AVERROR(EINVAL);
 206         }
 207
 208         cover->cover_frame = av_frame_alloc();
 209         if (!cover->cover_frame)
 210             return AVERROR(ENOMEM);
 211
 212         if ((ret = ff_load_image(cover->cover_frame->data, cover->cover_frame->linesize,
 213                                 &cover->cover_frame->width, &cover->cover_frame->height,
 214                                 &cover->cover_frame->format, cover->cover_filename, ctx)) < 0)
 215             return ret;
 216
 217         if (cover->cover_frame->format != AV_PIX_FMT_YUV420P && cover->cover_frame->format != AV_PIX_FMT_YUVJ420P) {
 218             av_log(ctx, AV_LOG_ERROR, "cover image is not a YUV420 image\n");
 219             return AVERROR(EINVAL);
 220         }
 221     }
 222
 223     return 0;
 224 }
 225
 226 static const AVFilterPad cover_rect_inputs[] = {
 227     {
 228         .name         = "default",
 229         .type         = AVMEDIA_TYPE_VIDEO,
 230         .config_props = config_input,
 231         .filter_frame = filter_frame,
 232     },
 233 };
 234
 235 const FFFilter ff_vf_cover_rect = {
 236     .p.name          = "cover_rect",
 237     .p.description   = NULL_IF_CONFIG_SMALL("Find and cover a user specified object."),
 238     .p.priv_class    = &cover_rect_class,
 239     .priv_size       = sizeof(CoverContext),
 240     .init            = init,
 241     .uninit          = uninit,
 242     FILTER_INPUTS(cover_rect_inputs),
 243     FILTER_OUTPUTS(ff_video_default_filterpad),
 244     FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
 245 };