GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/vf_cover_rect.c Lines: 0 107 0.0 %
Date: 2020-10-23 17:01:47 Branches: 0 80 0.0 %

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