FFmpeg coverage

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 "filters.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