avfilter/f_loop: make sure duration of frame is never zero
[ffmpeg.git] / libavfilter / vf_vibrance.c
1 /*
2  * Copyright (c) 2018 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 "avfilter.h"
24 #include "formats.h"
25 #include "internal.h"
26 #include "video.h"
27
28 typedef struct VibranceContext {
29     const AVClass *class;
30
31     float intensity;
32     float balance[3];
33     float lcoeffs[3];
34
35     int depth;
36
37     int (*do_slice)(AVFilterContext *s, void *arg,
38                     int jobnr, int nb_jobs);
39 } VibranceContext;
40
41 static inline float lerpf(float v0, float v1, float f)
42 {
43     return v0 + (v1 - v0) * f;
44 }
45
46 static int vibrance_slice8(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
47 {
48     VibranceContext *s = avctx->priv;
49     AVFrame *frame = arg;
50     const int width = frame->width;
51     const int height = frame->height;
52     const float gc = s->lcoeffs[0];
53     const float bc = s->lcoeffs[1];
54     const float rc = s->lcoeffs[2];
55     const float intensity = s->intensity;
56     const float gintensity = intensity * s->balance[0];
57     const float bintensity = intensity * s->balance[1];
58     const float rintensity = intensity * s->balance[2];
59     const int slice_start = (height * jobnr) / nb_jobs;
60     const int slice_end = (height * (jobnr + 1)) / nb_jobs;
61     const int glinesize = frame->linesize[0];
62     const int blinesize = frame->linesize[1];
63     const int rlinesize = frame->linesize[2];
64     uint8_t *gptr = frame->data[0] + slice_start * glinesize;
65     uint8_t *bptr = frame->data[1] + slice_start * blinesize;
66     uint8_t *rptr = frame->data[2] + slice_start * rlinesize;
67
68     for (int y = slice_start; y < slice_end; y++) {
69         for (int x = 0; x < width; x++) {
70             float g = gptr[x] / 255.f;
71             float b = bptr[x] / 255.f;
72             float r = rptr[x] / 255.f;
73             float max_color = FFMAX3(r, g, b);
74             float min_color = FFMIN3(r, g, b);
75             float color_saturation = max_color - min_color;
76             float luma = g * gc + r * rc + b * bc;
77             const float cg = 1.f + gintensity * (1.f - FFSIGN(gintensity) * color_saturation);
78             const float cb = 1.f + bintensity * (1.f - FFSIGN(bintensity) * color_saturation);
79             const float cr = 1.f + rintensity * (1.f - FFSIGN(rintensity) * color_saturation);
80
81             g = lerpf(luma, g, cg);
82             b = lerpf(luma, b, cb);
83             r = lerpf(luma, r, cr);
84
85             gptr[x] = av_clip_uint8(g * 255.f);
86             bptr[x] = av_clip_uint8(b * 255.f);
87             rptr[x] = av_clip_uint8(r * 255.f);
88         }
89
90         gptr += glinesize;
91         bptr += blinesize;
92         rptr += rlinesize;
93     }
94
95     return 0;
96 }
97
98 static int vibrance_slice16(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
99 {
100     VibranceContext *s = avctx->priv;
101     AVFrame *frame = arg;
102     const int depth = s->depth;
103     const float max = (1 << depth) - 1;
104     const float gc = s->lcoeffs[0];
105     const float bc = s->lcoeffs[1];
106     const float rc = s->lcoeffs[2];
107     const int width = frame->width;
108     const int height = frame->height;
109     const float intensity = s->intensity;
110     const float gintensity = intensity * s->balance[0];
111     const float bintensity = intensity * s->balance[1];
112     const float rintensity = intensity * s->balance[2];
113     const int slice_start = (height * jobnr) / nb_jobs;
114     const int slice_end = (height * (jobnr + 1)) / nb_jobs;
115     const int glinesize = frame->linesize[0] / 2;
116     const int blinesize = frame->linesize[1] / 2;
117     const int rlinesize = frame->linesize[2] / 2;
118     uint16_t *gptr = (uint16_t *)frame->data[0] + slice_start * glinesize;
119     uint16_t *bptr = (uint16_t *)frame->data[1] + slice_start * blinesize;
120     uint16_t *rptr = (uint16_t *)frame->data[2] + slice_start * rlinesize;
121
122     for (int y = slice_start; y < slice_end; y++) {
123         for (int x = 0; x < width; x++) {
124             float g = gptr[x] / max;
125             float b = bptr[x] / max;
126             float r = rptr[x] / max;
127             float max_color = FFMAX3(r, g, b);
128             float min_color = FFMIN3(r, g, b);
129             float color_saturation = max_color - min_color;
130             float luma = g * gc + r * rc + b * bc;
131             const float cg = 1.f + gintensity * (1.f - FFSIGN(gintensity) * color_saturation);
132             const float cb = 1.f + bintensity * (1.f - FFSIGN(bintensity) * color_saturation);
133             const float cr = 1.f + rintensity * (1.f - FFSIGN(rintensity) * color_saturation);
134
135             g = lerpf(luma, g, cg);
136             b = lerpf(luma, b, cb);
137             r = lerpf(luma, r, cr);
138
139             gptr[x] = av_clip_uintp2_c(g * max, depth);
140             bptr[x] = av_clip_uintp2_c(b * max, depth);
141             rptr[x] = av_clip_uintp2_c(r * max, depth);
142         }
143
144         gptr += glinesize;
145         bptr += blinesize;
146         rptr += rlinesize;
147     }
148
149     return 0;
150 }
151
152 static int filter_frame(AVFilterLink *link, AVFrame *frame)
153 {
154     AVFilterContext *avctx = link->dst;
155     VibranceContext *s = avctx->priv;
156     int res;
157
158     if (res = avctx->internal->execute(avctx, s->do_slice, frame, NULL,
159                                        FFMIN(frame->height, ff_filter_get_nb_threads(avctx))))
160         return res;
161
162     return ff_filter_frame(avctx->outputs[0], frame);
163 }
164
165 static av_cold int query_formats(AVFilterContext *avctx)
166 {
167     static const enum AVPixelFormat pixel_fmts[] = {
168         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
169         AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
170         AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
171         AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
172         AV_PIX_FMT_NONE
173     };
174
175     AVFilterFormats *formats = NULL;
176
177     formats = ff_make_format_list(pixel_fmts);
178     if (!formats)
179         return AVERROR(ENOMEM);
180
181     return ff_set_common_formats(avctx, formats);
182 }
183
184 static av_cold int config_input(AVFilterLink *inlink)
185 {
186     AVFilterContext *avctx = inlink->dst;
187     VibranceContext *s = avctx->priv;
188     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
189
190     s->depth = desc->comp[0].depth;
191     s->do_slice = s->depth <= 8 ? vibrance_slice8 : vibrance_slice16;
192
193     return 0;
194 }
195
196 static const AVFilterPad vibrance_inputs[] = {
197     {
198         .name           = "default",
199         .type           = AVMEDIA_TYPE_VIDEO,
200         .needs_writable = 1,
201         .filter_frame   = filter_frame,
202         .config_props   = config_input,
203     },
204     { NULL }
205 };
206
207 static const AVFilterPad vibrance_outputs[] = {
208     {
209         .name = "default",
210         .type = AVMEDIA_TYPE_VIDEO,
211     },
212     { NULL }
213 };
214
215 #define OFFSET(x) offsetof(VibranceContext, x)
216 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
217
218 static const AVOption vibrance_options[] = {
219     { "intensity", "set the intensity value",   OFFSET(intensity),  AV_OPT_TYPE_FLOAT, {.dbl=0},       -2,  2, VF },
220     { "rbal", "set the red balance value",      OFFSET(balance[2]), AV_OPT_TYPE_FLOAT, {.dbl=1},      -10, 10, VF },
221     { "gbal", "set the green balance value",    OFFSET(balance[0]), AV_OPT_TYPE_FLOAT, {.dbl=1},      -10, 10, VF },
222     { "bbal", "set the blue balance value",     OFFSET(balance[1]), AV_OPT_TYPE_FLOAT, {.dbl=1},      -10, 10, VF },
223     { "rlum", "set the red luma coefficient",   OFFSET(lcoeffs[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.072186}, 0,  1, VF },
224     { "glum", "set the green luma coefficient", OFFSET(lcoeffs[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.715158}, 0,  1, VF },
225     { "blum", "set the blue luma coefficient",  OFFSET(lcoeffs[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.212656}, 0,  1, VF },
226     { NULL }
227 };
228
229 AVFILTER_DEFINE_CLASS(vibrance);
230
231 AVFilter ff_vf_vibrance = {
232     .name          = "vibrance",
233     .description   = NULL_IF_CONFIG_SMALL("Boost or alter saturation."),
234     .priv_size     = sizeof(VibranceContext),
235     .priv_class    = &vibrance_class,
236     .query_formats = query_formats,
237     .inputs        = vibrance_inputs,
238     .outputs       = vibrance_outputs,
239     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
240 };