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