GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/vf_colorlevels.c Lines: 91 124 73.4 %
Date: 2020-08-13 15:06:06 Branches: 23 51 45.1 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2013 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/imgutils.h"
22
#include "libavutil/opt.h"
23
#include "libavutil/pixdesc.h"
24
#include "avfilter.h"
25
#include "drawutils.h"
26
#include "formats.h"
27
#include "internal.h"
28
#include "video.h"
29
30
#define R 0
31
#define G 1
32
#define B 2
33
#define A 3
34
35
typedef struct Range {
36
    double in_min, in_max;
37
    double out_min, out_max;
38
} Range;
39
40
typedef struct ColorLevelsContext {
41
    const AVClass *class;
42
    Range range[4];
43
    int nb_comp;
44
    int bpp;
45
    int step;
46
    uint8_t rgba_map[4];
47
    int linesize;
48
} ColorLevelsContext;
49
50
#define OFFSET(x) offsetof(ColorLevelsContext, x)
51
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
52
static const AVOption colorlevels_options[] = {
53
    { "rimin", "set input red black point",    OFFSET(range[R].in_min),  AV_OPT_TYPE_DOUBLE, {.dbl=0}, -1, 1, FLAGS },
54
    { "gimin", "set input green black point",  OFFSET(range[G].in_min),  AV_OPT_TYPE_DOUBLE, {.dbl=0}, -1, 1, FLAGS },
55
    { "bimin", "set input blue black point",   OFFSET(range[B].in_min),  AV_OPT_TYPE_DOUBLE, {.dbl=0}, -1, 1, FLAGS },
56
    { "aimin", "set input alpha black point",  OFFSET(range[A].in_min),  AV_OPT_TYPE_DOUBLE, {.dbl=0}, -1, 1, FLAGS },
57
    { "rimax", "set input red white point",    OFFSET(range[R].in_max),  AV_OPT_TYPE_DOUBLE, {.dbl=1}, -1, 1, FLAGS },
58
    { "gimax", "set input green white point",  OFFSET(range[G].in_max),  AV_OPT_TYPE_DOUBLE, {.dbl=1}, -1, 1, FLAGS },
59
    { "bimax", "set input blue white point",   OFFSET(range[B].in_max),  AV_OPT_TYPE_DOUBLE, {.dbl=1}, -1, 1, FLAGS },
60
    { "aimax", "set input alpha white point",  OFFSET(range[A].in_max),  AV_OPT_TYPE_DOUBLE, {.dbl=1}, -1, 1, FLAGS },
61
    { "romin", "set output red black point",   OFFSET(range[R].out_min), AV_OPT_TYPE_DOUBLE, {.dbl=0},  0, 1, FLAGS },
62
    { "gomin", "set output green black point", OFFSET(range[G].out_min), AV_OPT_TYPE_DOUBLE, {.dbl=0},  0, 1, FLAGS },
63
    { "bomin", "set output blue black point",  OFFSET(range[B].out_min), AV_OPT_TYPE_DOUBLE, {.dbl=0},  0, 1, FLAGS },
64
    { "aomin", "set output alpha black point", OFFSET(range[A].out_min), AV_OPT_TYPE_DOUBLE, {.dbl=0},  0, 1, FLAGS },
65
    { "romax", "set output red white point",   OFFSET(range[R].out_max), AV_OPT_TYPE_DOUBLE, {.dbl=1},  0, 1, FLAGS },
66
    { "gomax", "set output green white point", OFFSET(range[G].out_max), AV_OPT_TYPE_DOUBLE, {.dbl=1},  0, 1, FLAGS },
67
    { "bomax", "set output blue white point",  OFFSET(range[B].out_max), AV_OPT_TYPE_DOUBLE, {.dbl=1},  0, 1, FLAGS },
68
    { "aomax", "set output alpha white point", OFFSET(range[A].out_max), AV_OPT_TYPE_DOUBLE, {.dbl=1},  0, 1, FLAGS },
69
    { NULL }
70
};
71
72
AVFILTER_DEFINE_CLASS(colorlevels);
73
74
2
static int query_formats(AVFilterContext *ctx)
75
{
76
    static const enum AVPixelFormat pix_fmts[] = {
77
        AV_PIX_FMT_0RGB,  AV_PIX_FMT_0BGR,
78
        AV_PIX_FMT_ARGB,  AV_PIX_FMT_ABGR,
79
        AV_PIX_FMT_RGB0,  AV_PIX_FMT_BGR0,
80
        AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
81
        AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
82
        AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
83
        AV_PIX_FMT_RGBA,  AV_PIX_FMT_BGRA,
84
        AV_PIX_FMT_NONE
85
    };
86
87
2
    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
88
2
    if (!fmts_list)
89
        return AVERROR(ENOMEM);
90
2
    return ff_set_common_formats(ctx, fmts_list);
91
}
92
93
2
static int config_input(AVFilterLink *inlink)
94
{
95
2
    AVFilterContext *ctx = inlink->dst;
96
2
    ColorLevelsContext *s = ctx->priv;
97
2
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
98
99
2
    s->nb_comp = desc->nb_components;
100
2
    s->bpp = desc->comp[0].depth >> 3;
101
2
    s->step = (av_get_padded_bits_per_pixel(desc) >> 3) / s->bpp;
102
2
    s->linesize = inlink->w * s->step;
103
2
    ff_fill_rgba_map(s->rgba_map, inlink->format);
104
105
2
    return 0;
106
}
107
108
struct thread_data {
109
    const uint8_t *srcrow;
110
    uint8_t *dstrow;
111
    int dst_linesize;
112
    int src_linesize;
113
114
    double coeff;
115
    uint8_t offset;
116
117
    int h;
118
119
    int imin;
120
    int omin;
121
};
122
123
#define LOAD_COMMON\
124
    ColorLevelsContext *s = ctx->priv;\
125
    const struct thread_data *td = arg;\
126
\
127
    int process_h = td->h;\
128
    const int slice_start = (process_h *  jobnr   ) / nb_jobs;\
129
    const int slice_end   = (process_h * (jobnr+1)) / nb_jobs;\
130
    int x, y;\
131
    const uint8_t *srcrow = td->srcrow;\
132
    uint8_t *dstrow = td->dstrow;\
133
    const int step = s->step;\
134
    const uint8_t offset = td->offset;\
135
\
136
    int imin = td->imin;\
137
    int omin = td->omin;\
138
    double coeff = td->coeff;\
139
140
1350
static int colorlevel_slice_8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
141
{
142
1350
    LOAD_COMMON
143
144
44550
    for (y = slice_start; y < slice_end; y++) {
145
43200
        const uint8_t *src = srcrow + y * td->src_linesize;
146
43200
        uint8_t *dst = dstrow + y * td->dst_linesize;
147
148
15249600
        for (x = 0; x < s->linesize; x += step)
149
15206400
            dst[x + offset] = av_clip_uint8((src[x + offset] - imin) * coeff + omin);
150
    }
151
152
1350
    return 0;
153
}
154
155
1350
static int colorlevel_slice_16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
156
{
157
1350
    LOAD_COMMON
158
159
44550
    for (y = slice_start; y < slice_end; y++) {
160
43200
        const uint16_t *src = (const uint16_t *)(srcrow + y * td->src_linesize);
161
43200
        uint16_t *dst = (uint16_t *)(dstrow + y * td->dst_linesize);
162
163
15249600
        for (x = 0; x < s->linesize; x += step)
164
15206400
            dst[x + offset] = av_clip_uint16((src[x + offset] - imin) * coeff + omin);
165
    }
166
167
1350
    return 0;
168
}
169
170
100
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
171
{
172
100
    AVFilterContext *ctx = inlink->dst;
173
100
    ColorLevelsContext *s = ctx->priv;
174
100
    AVFilterLink *outlink = ctx->outputs[0];
175
100
    const int step = s->step;
176
    AVFrame *out;
177
    int x, y, i;
178
179
100
    if (av_frame_is_writable(in)) {
180
100
        out = in;
181
    } else {
182
        out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
183
        if (!out) {
184
            av_frame_free(&in);
185
            return AVERROR(ENOMEM);
186
        }
187
        av_frame_copy_props(out, in);
188
    }
189
190
100
    switch (s->bpp) {
191
50
    case 1:
192
200
        for (i = 0; i < s->nb_comp; i++) {
193
150
            Range *r = &s->range[i];
194
150
            const uint8_t offset = s->rgba_map[i];
195
150
            const uint8_t *srcrow = in->data[0];
196
150
            uint8_t *dstrow = out->data[0];
197
150
            int imin = lrint(r->in_min  * UINT8_MAX);
198
150
            int imax = lrint(r->in_max  * UINT8_MAX);
199
150
            int omin = lrint(r->out_min * UINT8_MAX);
200
150
            int omax = lrint(r->out_max * UINT8_MAX);
201
            double coeff;
202
            struct thread_data td;
203
204
150
            if (imin < 0) {
205
                imin = UINT8_MAX;
206
                for (y = 0; y < inlink->h; y++) {
207
                    const uint8_t *src = srcrow;
208
209
                    for (x = 0; x < s->linesize; x += step)
210
                        imin = FFMIN(imin, src[x + offset]);
211
                    srcrow += in->linesize[0];
212
                }
213
            }
214
150
            if (imax < 0) {
215
                srcrow = in->data[0];
216
                imax = 0;
217
                for (y = 0; y < inlink->h; y++) {
218
                    const uint8_t *src = srcrow;
219
220
                    for (x = 0; x < s->linesize; x += step)
221
                        imax = FFMAX(imax, src[x + offset]);
222
                    srcrow += in->linesize[0];
223
                }
224
            }
225
226
150
            srcrow = in->data[0];
227
150
            coeff = (omax - omin) / (double)(imax - imin);
228
229
150
            td.srcrow        = srcrow;
230
150
            td.dstrow        = dstrow;
231
150
            td.dst_linesize  = out->linesize[0];
232
150
            td.src_linesize  = in->linesize[0];
233
150
            td.coeff         = coeff;
234
150
            td.offset        = offset;
235
150
            td.h             = inlink->h;
236
150
            td.imin          = imin;
237
150
            td.omin          = omin;
238
239
300
            ctx->internal->execute(ctx, colorlevel_slice_8, &td, NULL,
240
300
                                   FFMIN(inlink->h, ff_filter_get_nb_threads(ctx)));
241
        }
242
50
        break;
243
50
    case 2:
244
200
        for (i = 0; i < s->nb_comp; i++) {
245
150
            Range *r = &s->range[i];
246
150
            const uint8_t offset = s->rgba_map[i];
247
150
            const uint8_t *srcrow = in->data[0];
248
150
            uint8_t *dstrow = out->data[0];
249
150
            int imin = lrint(r->in_min  * UINT16_MAX);
250
150
            int imax = lrint(r->in_max  * UINT16_MAX);
251
150
            int omin = lrint(r->out_min * UINT16_MAX);
252
150
            int omax = lrint(r->out_max * UINT16_MAX);
253
            double coeff;
254
            struct thread_data td;
255
256
150
            if (imin < 0) {
257
                imin = UINT16_MAX;
258
                for (y = 0; y < inlink->h; y++) {
259
                    const uint16_t *src = (const uint16_t *)srcrow;
260
261
                    for (x = 0; x < s->linesize; x += step)
262
                        imin = FFMIN(imin, src[x + offset]);
263
                    srcrow += in->linesize[0];
264
                }
265
            }
266
150
            if (imax < 0) {
267
                srcrow = in->data[0];
268
                imax = 0;
269
                for (y = 0; y < inlink->h; y++) {
270
                    const uint16_t *src = (const uint16_t *)srcrow;
271
272
                    for (x = 0; x < s->linesize; x += step)
273
                        imax = FFMAX(imax, src[x + offset]);
274
                    srcrow += in->linesize[0];
275
                }
276
            }
277
278
150
            srcrow = in->data[0];
279
150
            coeff = (omax - omin) / (double)(imax - imin);
280
281
150
            td.srcrow        = srcrow;
282
150
            td.dstrow        = dstrow;
283
150
            td.dst_linesize  = out->linesize[0];
284
150
            td.src_linesize  = in->linesize[0];
285
150
            td.coeff         = coeff;
286
150
            td.offset        = offset;
287
150
            td.h             = inlink->h;
288
150
            td.imin          = imin;
289
150
            td.omin          = omin;
290
291
300
            ctx->internal->execute(ctx, colorlevel_slice_16, &td, NULL,
292
300
                                   FFMIN(inlink->h, ff_filter_get_nb_threads(ctx)));
293
        }
294
    }
295
296
100
    if (in != out)
297
        av_frame_free(&in);
298
100
    return ff_filter_frame(outlink, out);
299
}
300
301
static const AVFilterPad colorlevels_inputs[] = {
302
    {
303
        .name         = "default",
304
        .type         = AVMEDIA_TYPE_VIDEO,
305
        .filter_frame = filter_frame,
306
        .config_props = config_input,
307
    },
308
    { NULL }
309
};
310
311
static const AVFilterPad colorlevels_outputs[] = {
312
    {
313
        .name = "default",
314
        .type = AVMEDIA_TYPE_VIDEO,
315
    },
316
    { NULL }
317
};
318
319
AVFilter ff_vf_colorlevels = {
320
    .name          = "colorlevels",
321
    .description   = NULL_IF_CONFIG_SMALL("Adjust the color levels."),
322
    .priv_size     = sizeof(ColorLevelsContext),
323
    .priv_class    = &colorlevels_class,
324
    .query_formats = query_formats,
325
    .inputs        = colorlevels_inputs,
326
    .outputs       = colorlevels_outputs,
327
    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
328
    .process_command = ff_filter_process_command,
329
};