FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_vibrance.c
Date: 2024-02-29 09:57:37
Exec Total Coverage
Lines: 0 276 0.0%
Functions: 0 7 0.0%
Branches: 0 136 0.0%

Line Branch Exec Source
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/pixdesc.h"
23 #include "avfilter.h"
24 #include "drawutils.h"
25 #include "internal.h"
26 #include "video.h"
27
28 #define R 0
29 #define G 1
30 #define B 2
31 #define A 3
32
33 typedef struct VibranceContext {
34 const AVClass *class;
35
36 float intensity;
37 float balance[3];
38 float lcoeffs[3];
39 int alternate;
40
41 int step;
42 int depth;
43 uint8_t rgba_map[4];
44
45 int (*do_slice)(AVFilterContext *s, void *arg,
46 int jobnr, int nb_jobs);
47 } VibranceContext;
48
49 static inline float lerpf(float v0, float v1, float f)
50 {
51 return v0 + (v1 - v0) * f;
52 }
53
54 typedef struct ThreadData {
55 AVFrame *out, *in;
56 } ThreadData;
57
58 static int vibrance_slice8(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
59 {
60 VibranceContext *s = avctx->priv;
61 ThreadData *td = arg;
62 AVFrame *frame = td->out;
63 AVFrame *in = td->in;
64 const int width = frame->width;
65 const int height = frame->height;
66 const float scale = 1.f / 255.f;
67 const float gc = s->lcoeffs[0];
68 const float bc = s->lcoeffs[1];
69 const float rc = s->lcoeffs[2];
70 const float intensity = s->intensity;
71 const float alternate = s->alternate ? 1.f : -1.f;
72 const float gintensity = intensity * s->balance[0];
73 const float bintensity = intensity * s->balance[1];
74 const float rintensity = intensity * s->balance[2];
75 const float sgintensity = alternate * FFSIGN(gintensity);
76 const float sbintensity = alternate * FFSIGN(bintensity);
77 const float srintensity = alternate * FFSIGN(rintensity);
78 const int slice_start = (height * jobnr) / nb_jobs;
79 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
80 const ptrdiff_t glinesize = frame->linesize[0];
81 const ptrdiff_t blinesize = frame->linesize[1];
82 const ptrdiff_t rlinesize = frame->linesize[2];
83 const ptrdiff_t alinesize = frame->linesize[3];
84 const ptrdiff_t gslinesize = in->linesize[0];
85 const ptrdiff_t bslinesize = in->linesize[1];
86 const ptrdiff_t rslinesize = in->linesize[2];
87 const ptrdiff_t aslinesize = in->linesize[3];
88 const uint8_t *gsrc = in->data[0] + slice_start * glinesize;
89 const uint8_t *bsrc = in->data[1] + slice_start * blinesize;
90 const uint8_t *rsrc = in->data[2] + slice_start * rlinesize;
91 uint8_t *gptr = frame->data[0] + slice_start * glinesize;
92 uint8_t *bptr = frame->data[1] + slice_start * blinesize;
93 uint8_t *rptr = frame->data[2] + slice_start * rlinesize;
94 const uint8_t *asrc = in->data[3];
95 uint8_t *aptr = frame->data[3];
96
97 for (int y = slice_start; y < slice_end; y++) {
98 for (int x = 0; x < width; x++) {
99 float g = gsrc[x] * scale;
100 float b = bsrc[x] * scale;
101 float r = rsrc[x] * scale;
102 float max_color = FFMAX3(r, g, b);
103 float min_color = FFMIN3(r, g, b);
104 float color_saturation = max_color - min_color;
105 float luma = g * gc + r * rc + b * bc;
106 const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
107 const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
108 const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
109
110 g = lerpf(luma, g, cg);
111 b = lerpf(luma, b, cb);
112 r = lerpf(luma, r, cr);
113
114 gptr[x] = av_clip_uint8(g * 255.f);
115 bptr[x] = av_clip_uint8(b * 255.f);
116 rptr[x] = av_clip_uint8(r * 255.f);
117 }
118
119 if (aptr && alinesize && frame != in)
120 memcpy(aptr + alinesize * y, asrc + aslinesize * y, width);
121
122 gsrc += gslinesize;
123 bsrc += bslinesize;
124 rsrc += rslinesize;
125 gptr += glinesize;
126 bptr += blinesize;
127 rptr += rlinesize;
128 }
129
130 return 0;
131 }
132
133 static int vibrance_slice16(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
134 {
135 VibranceContext *s = avctx->priv;
136 ThreadData *td = arg;
137 AVFrame *frame = td->out;
138 AVFrame *in = td->in;
139 const int depth = s->depth;
140 const float max = (1 << depth) - 1;
141 const float scale = 1.f / max;
142 const float gc = s->lcoeffs[0];
143 const float bc = s->lcoeffs[1];
144 const float rc = s->lcoeffs[2];
145 const int width = frame->width;
146 const int height = frame->height;
147 const float intensity = s->intensity;
148 const float alternate = s->alternate ? 1.f : -1.f;
149 const float gintensity = intensity * s->balance[0];
150 const float bintensity = intensity * s->balance[1];
151 const float rintensity = intensity * s->balance[2];
152 const float sgintensity = alternate * FFSIGN(gintensity);
153 const float sbintensity = alternate * FFSIGN(bintensity);
154 const float srintensity = alternate * FFSIGN(rintensity);
155 const int slice_start = (height * jobnr) / nb_jobs;
156 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
157 const ptrdiff_t gslinesize = in->linesize[0] / 2;
158 const ptrdiff_t bslinesize = in->linesize[1] / 2;
159 const ptrdiff_t rslinesize = in->linesize[2] / 2;
160 const ptrdiff_t aslinesize = in->linesize[3] / 2;
161 const ptrdiff_t glinesize = frame->linesize[0] / 2;
162 const ptrdiff_t blinesize = frame->linesize[1] / 2;
163 const ptrdiff_t rlinesize = frame->linesize[2] / 2;
164 const ptrdiff_t alinesize = frame->linesize[3] / 2;
165 const uint16_t *gsrc = (const uint16_t *)in->data[0] + slice_start * gslinesize;
166 const uint16_t *bsrc = (const uint16_t *)in->data[1] + slice_start * bslinesize;
167 const uint16_t *rsrc = (const uint16_t *)in->data[2] + slice_start * rslinesize;
168 uint16_t *gptr = (uint16_t *)frame->data[0] + slice_start * glinesize;
169 uint16_t *bptr = (uint16_t *)frame->data[1] + slice_start * blinesize;
170 uint16_t *rptr = (uint16_t *)frame->data[2] + slice_start * rlinesize;
171 const uint16_t *asrc = (const uint16_t *)in->data[3];
172 uint16_t *aptr = (uint16_t *)frame->data[3];
173
174 for (int y = slice_start; y < slice_end; y++) {
175 for (int x = 0; x < width; x++) {
176 float g = gsrc[x] * scale;
177 float b = bsrc[x] * scale;
178 float r = rsrc[x] * scale;
179 float max_color = FFMAX3(r, g, b);
180 float min_color = FFMIN3(r, g, b);
181 float color_saturation = max_color - min_color;
182 float luma = g * gc + r * rc + b * bc;
183 const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
184 const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
185 const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
186
187 g = lerpf(luma, g, cg);
188 b = lerpf(luma, b, cb);
189 r = lerpf(luma, r, cr);
190
191 gptr[x] = av_clip_uintp2_c(g * max, depth);
192 bptr[x] = av_clip_uintp2_c(b * max, depth);
193 rptr[x] = av_clip_uintp2_c(r * max, depth);
194 }
195
196 if (aptr && alinesize && frame != in)
197 memcpy(aptr + alinesize * y, asrc + aslinesize * y, width * 2);
198
199 gsrc += gslinesize;
200 bsrc += bslinesize;
201 rsrc += rslinesize;
202 gptr += glinesize;
203 bptr += blinesize;
204 rptr += rlinesize;
205 }
206
207 return 0;
208 }
209
210 static int vibrance_slice8p(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
211 {
212 VibranceContext *s = avctx->priv;
213 ThreadData *td = arg;
214 AVFrame *frame = td->out;
215 AVFrame *in = td->in;
216 const int step = s->step;
217 const int width = frame->width;
218 const int height = frame->height;
219 const float scale = 1.f / 255.f;
220 const float gc = s->lcoeffs[0];
221 const float bc = s->lcoeffs[1];
222 const float rc = s->lcoeffs[2];
223 const uint8_t roffset = s->rgba_map[R];
224 const uint8_t goffset = s->rgba_map[G];
225 const uint8_t boffset = s->rgba_map[B];
226 const uint8_t aoffset = s->rgba_map[A];
227 const float intensity = s->intensity;
228 const float alternate = s->alternate ? 1.f : -1.f;
229 const float gintensity = intensity * s->balance[0];
230 const float bintensity = intensity * s->balance[1];
231 const float rintensity = intensity * s->balance[2];
232 const float sgintensity = alternate * FFSIGN(gintensity);
233 const float sbintensity = alternate * FFSIGN(bintensity);
234 const float srintensity = alternate * FFSIGN(rintensity);
235 const int slice_start = (height * jobnr) / nb_jobs;
236 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
237 const ptrdiff_t linesize = frame->linesize[0];
238 const ptrdiff_t slinesize = in->linesize[0];
239 const uint8_t *src = in->data[0] + slice_start * slinesize;
240 uint8_t *ptr = frame->data[0] + slice_start * linesize;
241
242 for (int y = slice_start; y < slice_end; y++) {
243 for (int x = 0; x < width; x++) {
244 float g = src[x * step + goffset] * scale;
245 float b = src[x * step + boffset] * scale;
246 float r = src[x * step + roffset] * scale;
247 float max_color = FFMAX3(r, g, b);
248 float min_color = FFMIN3(r, g, b);
249 float color_saturation = max_color - min_color;
250 float luma = g * gc + r * rc + b * bc;
251 const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
252 const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
253 const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
254
255 g = lerpf(luma, g, cg);
256 b = lerpf(luma, b, cb);
257 r = lerpf(luma, r, cr);
258
259 ptr[x * step + goffset] = av_clip_uint8(g * 255.f);
260 ptr[x * step + boffset] = av_clip_uint8(b * 255.f);
261 ptr[x * step + roffset] = av_clip_uint8(r * 255.f);
262
263 if (frame != in)
264 ptr[x * step + aoffset] = src[x * step + aoffset];
265 }
266
267 ptr += linesize;
268 src += slinesize;
269 }
270
271 return 0;
272 }
273
274 static int vibrance_slice16p(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
275 {
276 VibranceContext *s = avctx->priv;
277 ThreadData *td = arg;
278 AVFrame *frame = td->out;
279 AVFrame *in = td->in;
280 const int step = s->step;
281 const int depth = s->depth;
282 const float max = (1 << depth) - 1;
283 const float scale = 1.f / max;
284 const float gc = s->lcoeffs[0];
285 const float bc = s->lcoeffs[1];
286 const float rc = s->lcoeffs[2];
287 const uint8_t roffset = s->rgba_map[R];
288 const uint8_t goffset = s->rgba_map[G];
289 const uint8_t boffset = s->rgba_map[B];
290 const uint8_t aoffset = s->rgba_map[A];
291 const int width = frame->width;
292 const int height = frame->height;
293 const float intensity = s->intensity;
294 const float alternate = s->alternate ? 1.f : -1.f;
295 const float gintensity = intensity * s->balance[0];
296 const float bintensity = intensity * s->balance[1];
297 const float rintensity = intensity * s->balance[2];
298 const float sgintensity = alternate * FFSIGN(gintensity);
299 const float sbintensity = alternate * FFSIGN(bintensity);
300 const float srintensity = alternate * FFSIGN(rintensity);
301 const int slice_start = (height * jobnr) / nb_jobs;
302 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
303 const ptrdiff_t linesize = frame->linesize[0] / 2;
304 const ptrdiff_t slinesize = in->linesize[0] / 2;
305 const uint16_t *src = (const uint16_t *)in->data[0] + slice_start * slinesize;
306 uint16_t *ptr = (uint16_t *)frame->data[0] + slice_start * linesize;
307
308 for (int y = slice_start; y < slice_end; y++) {
309 for (int x = 0; x < width; x++) {
310 float g = src[x * step + goffset] * scale;
311 float b = src[x * step + boffset] * scale;
312 float r = src[x * step + roffset] * scale;
313 float max_color = FFMAX3(r, g, b);
314 float min_color = FFMIN3(r, g, b);
315 float color_saturation = max_color - min_color;
316 float luma = g * gc + r * rc + b * bc;
317 const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
318 const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
319 const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
320
321 g = lerpf(luma, g, cg);
322 b = lerpf(luma, b, cb);
323 r = lerpf(luma, r, cr);
324
325 ptr[x * step + goffset] = av_clip_uintp2_c(g * max, depth);
326 ptr[x * step + boffset] = av_clip_uintp2_c(b * max, depth);
327 ptr[x * step + roffset] = av_clip_uintp2_c(r * max, depth);
328 if (frame != in)
329 ptr[x * step + aoffset] = src[x * step + aoffset];
330 }
331
332 ptr += linesize;
333 src += slinesize;
334 }
335
336 return 0;
337 }
338
339 static int filter_frame(AVFilterLink *link, AVFrame *in)
340 {
341 AVFilterContext *avctx = link->dst;
342 AVFilterLink *outlink = avctx->outputs[0];
343 VibranceContext *s = avctx->priv;
344 ThreadData td;
345 AVFrame *out;
346 int res;
347
348 if (av_frame_is_writable(in)) {
349 out = in;
350 } else {
351 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
352 if (!out) {
353 av_frame_free(&in);
354 return AVERROR(ENOMEM);
355 }
356 av_frame_copy_props(out, in);
357 }
358
359 td.out = out;
360 td.in = in;
361 if (res = ff_filter_execute(avctx, s->do_slice, &td, NULL,
362 FFMIN(out->height, ff_filter_get_nb_threads(avctx))))
363 return res;
364
365 if (out != in)
366 av_frame_free(&in);
367 return ff_filter_frame(outlink, out);
368 }
369
370 static const enum AVPixelFormat pixel_fmts[] = {
371 AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
372 AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
373 AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
374 AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
375 AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
376 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
377 AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
378 AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
379 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
380 AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
381 AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
382 AV_PIX_FMT_NONE
383 };
384
385 static av_cold int config_input(AVFilterLink *inlink)
386 {
387 AVFilterContext *avctx = inlink->dst;
388 VibranceContext *s = avctx->priv;
389 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
390 int planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
391
392 s->step = desc->nb_components;
393 if (inlink->format == AV_PIX_FMT_RGB0 ||
394 inlink->format == AV_PIX_FMT_0RGB ||
395 inlink->format == AV_PIX_FMT_BGR0 ||
396 inlink->format == AV_PIX_FMT_0BGR)
397 s->step = 4;
398
399 s->depth = desc->comp[0].depth;
400 s->do_slice = s->depth <= 8 ? vibrance_slice8 : vibrance_slice16;
401 if (!planar)
402 s->do_slice = s->depth <= 8 ? vibrance_slice8p : vibrance_slice16p;
403
404 ff_fill_rgba_map(s->rgba_map, inlink->format);
405
406 return 0;
407 }
408
409 static const AVFilterPad vibrance_inputs[] = {
410 {
411 .name = "default",
412 .type = AVMEDIA_TYPE_VIDEO,
413 .filter_frame = filter_frame,
414 .config_props = config_input,
415 },
416 };
417
418 #define OFFSET(x) offsetof(VibranceContext, x)
419 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
420
421 static const AVOption vibrance_options[] = {
422 { "intensity", "set the intensity value", OFFSET(intensity), AV_OPT_TYPE_FLOAT, {.dbl=0}, -2, 2, VF },
423 { "rbal", "set the red balance value", OFFSET(balance[2]), AV_OPT_TYPE_FLOAT, {.dbl=1}, -10, 10, VF },
424 { "gbal", "set the green balance value", OFFSET(balance[0]), AV_OPT_TYPE_FLOAT, {.dbl=1}, -10, 10, VF },
425 { "bbal", "set the blue balance value", OFFSET(balance[1]), AV_OPT_TYPE_FLOAT, {.dbl=1}, -10, 10, VF },
426 { "rlum", "set the red luma coefficient", OFFSET(lcoeffs[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.072186}, 0, 1, VF },
427 { "glum", "set the green luma coefficient", OFFSET(lcoeffs[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.715158}, 0, 1, VF },
428 { "blum", "set the blue luma coefficient", OFFSET(lcoeffs[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.212656}, 0, 1, VF },
429 { "alternate", "use alternate colors", OFFSET(alternate), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF },
430 { NULL }
431 };
432
433 AVFILTER_DEFINE_CLASS(vibrance);
434
435 const AVFilter ff_vf_vibrance = {
436 .name = "vibrance",
437 .description = NULL_IF_CONFIG_SMALL("Boost or alter saturation."),
438 .priv_size = sizeof(VibranceContext),
439 .priv_class = &vibrance_class,
440 FILTER_INPUTS(vibrance_inputs),
441 FILTER_OUTPUTS(ff_video_default_filterpad),
442 FILTER_PIXFMTS_ARRAY(pixel_fmts),
443 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
444 .process_command = ff_filter_process_command,
445 };
446