FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_colortemperature.c
Date: 2024-04-12 08:31:17
Exec Total Coverage
Lines: 0 187 0.0%
Functions: 0 10 0.0%
Branches: 0 164 0.0%

Line Branch Exec Source
1 /*
2 * Copyright (c) 2021 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 <float.h>
22
23 #include "libavutil/opt.h"
24 #include "libavutil/pixdesc.h"
25 #include "avfilter.h"
26 #include "drawutils.h"
27 #include "internal.h"
28 #include "video.h"
29
30 #define R 0
31 #define G 1
32 #define B 2
33
34 typedef struct ColorTemperatureContext {
35 const AVClass *class;
36
37 float temperature;
38 float mix;
39 float preserve;
40
41 float color[3];
42
43 int step;
44 int depth;
45 uint8_t rgba_map[4];
46
47 int (*do_slice)(AVFilterContext *s, void *arg,
48 int jobnr, int nb_jobs);
49 } ColorTemperatureContext;
50
51 static float saturate(float input)
52 {
53 return av_clipf(input, 0.f, 1.f);
54 }
55
56 static void kelvin2rgb(float k, float *rgb)
57 {
58 float kelvin = k / 100.0f;
59
60 if (kelvin <= 66.0f) {
61 rgb[0] = 1.0f;
62 rgb[1] = saturate(0.39008157876901960784f * logf(kelvin) - 0.63184144378862745098f);
63 } else {
64 const float t = fmaxf(kelvin - 60.0f, 0.0f);
65 rgb[0] = saturate(1.29293618606274509804f * powf(t, -0.1332047592f));
66 rgb[1] = saturate(1.12989086089529411765f * powf(t, -0.0755148492f));
67 }
68
69 if (kelvin >= 66.0f)
70 rgb[2] = 1.0f;
71 else if (kelvin <= 19.0f)
72 rgb[2] = 0.0f;
73 else
74 rgb[2] = saturate(0.54320678911019607843f * logf(kelvin - 10.0f) - 1.19625408914f);
75 }
76
77 static float lerpf(float v0, float v1, float f)
78 {
79 return v0 + (v1 - v0) * f;
80 }
81
82 #define PROCESS() \
83 nr = r * color[0]; \
84 ng = g * color[1]; \
85 nb = b * color[2]; \
86 \
87 nr = lerpf(r, nr, mix); \
88 ng = lerpf(g, ng, mix); \
89 nb = lerpf(b, nb, mix); \
90 \
91 l0 = (FFMAX3(r, g, b) + FFMIN3(r, g, b)) + FLT_EPSILON; \
92 l1 = (FFMAX3(nr, ng, nb) + FFMIN3(nr, ng, nb)) + FLT_EPSILON; \
93 l = l0 / l1; \
94 \
95 r = nr * l; \
96 g = ng * l; \
97 b = nb * l; \
98 \
99 nr = lerpf(nr, r, preserve); \
100 ng = lerpf(ng, g, preserve); \
101 nb = lerpf(nb, b, preserve);
102
103 static int temperature_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
104 {
105 ColorTemperatureContext *s = ctx->priv;
106 AVFrame *frame = arg;
107 const int width = frame->width;
108 const int height = frame->height;
109 const float mix = s->mix;
110 const float preserve = s->preserve;
111 const float *color = s->color;
112 const int slice_start = (height * jobnr) / nb_jobs;
113 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
114 const ptrdiff_t glinesize = frame->linesize[0];
115 const ptrdiff_t blinesize = frame->linesize[1];
116 const ptrdiff_t rlinesize = frame->linesize[2];
117 uint8_t *gptr = frame->data[0] + slice_start * glinesize;
118 uint8_t *bptr = frame->data[1] + slice_start * blinesize;
119 uint8_t *rptr = frame->data[2] + slice_start * rlinesize;
120
121 for (int y = slice_start; y < slice_end; y++) {
122 for (int x = 0; x < width; x++) {
123 float g = gptr[x];
124 float b = bptr[x];
125 float r = rptr[x];
126 float nr, ng, nb;
127 float l0, l1, l;
128
129 PROCESS()
130
131 gptr[x] = av_clip_uint8(ng);
132 bptr[x] = av_clip_uint8(nb);
133 rptr[x] = av_clip_uint8(nr);
134 }
135
136 gptr += glinesize;
137 bptr += blinesize;
138 rptr += rlinesize;
139 }
140
141 return 0;
142 }
143
144 static int temperature_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
145 {
146 ColorTemperatureContext *s = ctx->priv;
147 AVFrame *frame = arg;
148 const int depth = s->depth;
149 const int width = frame->width;
150 const int height = frame->height;
151 const float preserve = s->preserve;
152 const float mix = s->mix;
153 const float *color = s->color;
154 const int slice_start = (height * jobnr) / nb_jobs;
155 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
156 const ptrdiff_t glinesize = frame->linesize[0] / sizeof(uint16_t);
157 const ptrdiff_t blinesize = frame->linesize[1] / sizeof(uint16_t);
158 const ptrdiff_t rlinesize = frame->linesize[2] / sizeof(uint16_t);
159 uint16_t *gptr = (uint16_t *)frame->data[0] + slice_start * glinesize;
160 uint16_t *bptr = (uint16_t *)frame->data[1] + slice_start * blinesize;
161 uint16_t *rptr = (uint16_t *)frame->data[2] + slice_start * rlinesize;
162
163 for (int y = slice_start; y < slice_end; y++) {
164 for (int x = 0; x < width; x++) {
165 float g = gptr[x];
166 float b = bptr[x];
167 float r = rptr[x];
168 float nr, ng, nb;
169 float l0, l1, l;
170
171 PROCESS()
172
173 gptr[x] = av_clip_uintp2_c(ng, depth);
174 bptr[x] = av_clip_uintp2_c(nb, depth);
175 rptr[x] = av_clip_uintp2_c(nr, depth);
176 }
177
178 gptr += glinesize;
179 bptr += blinesize;
180 rptr += rlinesize;
181 }
182
183 return 0;
184 }
185
186 static int temperature_slice32(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
187 {
188 ColorTemperatureContext *s = ctx->priv;
189 AVFrame *frame = arg;
190 const int width = frame->width;
191 const int height = frame->height;
192 const float preserve = s->preserve;
193 const float mix = s->mix;
194 const float *color = s->color;
195 const int slice_start = (height * jobnr) / nb_jobs;
196 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
197 const ptrdiff_t glinesize = frame->linesize[0] / sizeof(float);
198 const ptrdiff_t blinesize = frame->linesize[1] / sizeof(float);
199 const ptrdiff_t rlinesize = frame->linesize[2] / sizeof(float);
200 float *gptr = (float *)frame->data[0] + slice_start * glinesize;
201 float *bptr = (float *)frame->data[1] + slice_start * blinesize;
202 float *rptr = (float *)frame->data[2] + slice_start * rlinesize;
203
204 for (int y = slice_start; y < slice_end; y++) {
205 for (int x = 0; x < width; x++) {
206 float g = gptr[x];
207 float b = bptr[x];
208 float r = rptr[x];
209 float nr, ng, nb;
210 float l0, l1, l;
211
212 PROCESS()
213
214 gptr[x] = ng;
215 bptr[x] = nb;
216 rptr[x] = nr;
217 }
218
219 gptr += glinesize;
220 bptr += blinesize;
221 rptr += rlinesize;
222 }
223
224 return 0;
225 }
226
227 static int temperature_slice8p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
228 {
229 ColorTemperatureContext *s = ctx->priv;
230 AVFrame *frame = arg;
231 const int step = s->step;
232 const int width = frame->width;
233 const int height = frame->height;
234 const float mix = s->mix;
235 const float preserve = s->preserve;
236 const float *color = s->color;
237 const uint8_t roffset = s->rgba_map[R];
238 const uint8_t goffset = s->rgba_map[G];
239 const uint8_t boffset = s->rgba_map[B];
240 const int slice_start = (height * jobnr) / nb_jobs;
241 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
242 const ptrdiff_t linesize = frame->linesize[0];
243 uint8_t *ptr = frame->data[0] + slice_start * linesize;
244
245 for (int y = slice_start; y < slice_end; y++) {
246 for (int x = 0; x < width; x++) {
247 float g = ptr[x * step + goffset];
248 float b = ptr[x * step + boffset];
249 float r = ptr[x * step + roffset];
250 float nr, ng, nb;
251 float l0, l1, l;
252
253 PROCESS()
254
255 ptr[x * step + goffset] = av_clip_uint8(ng);
256 ptr[x * step + boffset] = av_clip_uint8(nb);
257 ptr[x * step + roffset] = av_clip_uint8(nr);
258 }
259
260 ptr += linesize;
261 }
262
263 return 0;
264 }
265
266 static int temperature_slice16p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
267 {
268 ColorTemperatureContext *s = ctx->priv;
269 AVFrame *frame = arg;
270 const int step = s->step;
271 const int depth = s->depth;
272 const int width = frame->width;
273 const int height = frame->height;
274 const float preserve = s->preserve;
275 const float mix = s->mix;
276 const float *color = s->color;
277 const uint8_t roffset = s->rgba_map[R];
278 const uint8_t goffset = s->rgba_map[G];
279 const uint8_t boffset = s->rgba_map[B];
280 const int slice_start = (height * jobnr) / nb_jobs;
281 const int slice_end = (height * (jobnr + 1)) / nb_jobs;
282 const ptrdiff_t linesize = frame->linesize[0] / sizeof(uint16_t);
283 uint16_t *ptr = (uint16_t *)frame->data[0] + slice_start * linesize;
284
285 for (int y = slice_start; y < slice_end; y++) {
286 for (int x = 0; x < width; x++) {
287 float g = ptr[x * step + goffset];
288 float b = ptr[x * step + boffset];
289 float r = ptr[x * step + roffset];
290 float nr, ng, nb;
291 float l0, l1, l;
292
293 PROCESS()
294
295 ptr[x * step + goffset] = av_clip_uintp2_c(ng, depth);
296 ptr[x * step + boffset] = av_clip_uintp2_c(nb, depth);
297 ptr[x * step + roffset] = av_clip_uintp2_c(nr, depth);
298 }
299
300 ptr += linesize;
301 }
302
303 return 0;
304 }
305
306 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
307 {
308 AVFilterContext *ctx = inlink->dst;
309 ColorTemperatureContext *s = ctx->priv;
310
311 kelvin2rgb(s->temperature, s->color);
312
313 ff_filter_execute(ctx, s->do_slice, frame, NULL,
314 FFMIN(frame->height, ff_filter_get_nb_threads(ctx)));
315
316 return ff_filter_frame(ctx->outputs[0], frame);
317 }
318
319 static const enum AVPixelFormat pixel_fmts[] = {
320 AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
321 AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
322 AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
323 AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
324 AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
325 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
326 AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
327 AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
328 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
329 AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32,
330 AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
331 AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
332 AV_PIX_FMT_NONE
333 };
334
335 static av_cold int config_input(AVFilterLink *inlink)
336 {
337 AVFilterContext *ctx = inlink->dst;
338 ColorTemperatureContext *s = ctx->priv;
339 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
340 int planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
341
342 s->step = desc->nb_components;
343 if (inlink->format == AV_PIX_FMT_RGB0 ||
344 inlink->format == AV_PIX_FMT_0RGB ||
345 inlink->format == AV_PIX_FMT_BGR0 ||
346 inlink->format == AV_PIX_FMT_0BGR)
347 s->step = 4;
348
349 s->depth = desc->comp[0].depth;
350 s->do_slice = s->depth <= 8 ? temperature_slice8 : temperature_slice16;
351 if (!planar)
352 s->do_slice = s->depth <= 8 ? temperature_slice8p : temperature_slice16p;
353 if (s->depth == 32)
354 s->do_slice = temperature_slice32;
355
356 ff_fill_rgba_map(s->rgba_map, inlink->format);
357
358 return 0;
359 }
360
361 static const AVFilterPad inputs[] = {
362 {
363 .name = "default",
364 .type = AVMEDIA_TYPE_VIDEO,
365 .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
366 .filter_frame = filter_frame,
367 .config_props = config_input,
368 },
369 };
370
371 #define OFFSET(x) offsetof(ColorTemperatureContext, x)
372 #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
373
374 static const AVOption colortemperature_options[] = {
375 { "temperature", "set the temperature in Kelvin", OFFSET(temperature), AV_OPT_TYPE_FLOAT, {.dbl=6500}, 1000, 40000, VF },
376 { "mix", "set the mix with filtered output", OFFSET(mix), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, VF },
377 { "pl", "set the amount of preserving lightness", OFFSET(preserve), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, VF },
378 { NULL }
379 };
380
381 AVFILTER_DEFINE_CLASS(colortemperature);
382
383 const AVFilter ff_vf_colortemperature = {
384 .name = "colortemperature",
385 .description = NULL_IF_CONFIG_SMALL("Adjust color temperature of video."),
386 .priv_size = sizeof(ColorTemperatureContext),
387 .priv_class = &colortemperature_class,
388 FILTER_INPUTS(inputs),
389 FILTER_OUTPUTS(ff_video_default_filterpad),
390 FILTER_PIXFMTS_ARRAY(pixel_fmts),
391 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
392 .process_command = ff_filter_process_command,
393 };
394