FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/vf_colorbalance.c
Date: 2022-12-09 07:38:14
Exec Total Coverage
Lines: 149 229 65.1%
Functions: 6 9 66.7%
Branches: 64 148 43.2%
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/opt.h"
22 #include "libavutil/pixdesc.h"
23 #include "avfilter.h"
24 #include "drawutils.h"
25 #include "formats.h"
26 #include "internal.h"
27 #include "video.h"
28
29 #define R 0
30 #define G 1
31 #define B 2
32 #define A 3
33
34 typedef struct ThreadData {
35 AVFrame *in, *out;
36 } ThreadData;
37
38 typedef struct Range {
39 float shadows;
40 float midtones;
41 float highlights;
42 } Range;
43
44 typedef struct ColorBalanceContext {
45 const AVClass *class;
46 Range cyan_red;
47 Range magenta_green;
48 Range yellow_blue;
49 int preserve_lightness;
50
51 uint8_t rgba_map[4];
52 int depth;
53 int max;
54 int step;
55
56 int (*color_balance)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
57 } ColorBalanceContext;
58
59 #define OFFSET(x) offsetof(ColorBalanceContext, x)
60 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
61 static const AVOption colorbalance_options[] = {
62 { "rs", "set red shadows", OFFSET(cyan_red.shadows), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
63 { "gs", "set green shadows", OFFSET(magenta_green.shadows), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
64 { "bs", "set blue shadows", OFFSET(yellow_blue.shadows), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
65 { "rm", "set red midtones", OFFSET(cyan_red.midtones), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
66 { "gm", "set green midtones", OFFSET(magenta_green.midtones), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
67 { "bm", "set blue midtones", OFFSET(yellow_blue.midtones), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
68 { "rh", "set red highlights", OFFSET(cyan_red.highlights), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
69 { "gh", "set green highlights", OFFSET(magenta_green.highlights), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
70 { "bh", "set blue highlights", OFFSET(yellow_blue.highlights), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, FLAGS },
71 { "pl", "preserve lightness", OFFSET(preserve_lightness), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
72 { NULL }
73 };
74
75 AVFILTER_DEFINE_CLASS(colorbalance);
76
77 static const enum AVPixelFormat pix_fmts[] = {
78 AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
79 AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
80 AV_PIX_FMT_ABGR, AV_PIX_FMT_ARGB,
81 AV_PIX_FMT_0BGR, AV_PIX_FMT_0RGB,
82 AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
83 AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
84 AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
85 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
86 AV_PIX_FMT_GBRP9,
87 AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
88 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
89 AV_PIX_FMT_GBRP14,
90 AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,
91 AV_PIX_FMT_NONE
92 };
93
94 3649536 static float get_component(float v, float l,
95 float s, float m, float h)
96 {
97 3649536 const float a = 4.f, b = 0.333f, scale = 0.7f;
98
99 3649536 s *= av_clipf((b - l) * a + 0.5f, 0.f, 1.f) * scale;
100 3649536 m *= av_clipf((l - b) * a + 0.5f, 0.f, 1.f) * av_clipf((1.f - l - b) * a + 0.5f, 0.f, 1.f) * scale;
101 3649536 h *= av_clipf((l + b - 1) * a + 0.5f, 0.f, 1.f) * scale;
102
103 3649536 v += s;
104 3649536 v += m;
105 3649536 v += h;
106
107 3649536 return av_clipf(v, 0.f, 1.f);
108 }
109
110 ✗ static float hfun(float n, float h, float s, float l)
111 {
112 ✗ float a = s * FFMIN(l, 1.f - l);
113 ✗ float k = fmodf(n + h / 30.f, 12.f);
114
115 ✗ return av_clipf(l - a * FFMAX(FFMIN3(k - 3.f, 9.f - k, 1), -1.f), 0.f, 1.f);
116 }
117
118 ✗ static void preservel(float *r, float *g, float *b, float l)
119 {
120 ✗ float max = FFMAX3(*r, *g, *b);
121 ✗ float min = FFMIN3(*r, *g, *b);
122 float h, s;
123
124 ✗ l *= 0.5f;
125
126 ✗ if (*r == *g && *g == *b) {
127 ✗ h = 0.f;
128 ✗ } else if (max == *r) {
129 ✗ h = 60.f * (0.f + (*g - *b) / (max - min));
130 ✗ } else if (max == *g) {
131 ✗ h = 60.f * (2.f + (*b - *r) / (max - min));
132 ✗ } else if (max == *b) {
133 ✗ h = 60.f * (4.f + (*r - *g) / (max - min));
134 } else {
135 ✗ h = 0.f;
136 }
137 ✗ if (h < 0.f)
138 ✗ h += 360.f;
139
140 ✗ if (max == 1.f || min == 0.f) {
141 ✗ s = 0.f;
142 } else {
143 ✗ s = (max - min) / (1.f - (FFABS(2.f * l - 1.f)));
144 }
145
146 ✗ *r = hfun(0.f, h, s, l);
147 ✗ *g = hfun(8.f, h, s, l);
148 ✗ *b = hfun(4.f, h, s, l);
149 }
150
151 54 static int color_balance8_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
152 {
153 54 ColorBalanceContext *s = ctx->priv;
154 54 ThreadData *td = arg;
155 54 AVFrame *in = td->in;
156 54 AVFrame *out = td->out;
157 54 const int slice_start = (out->height * jobnr) / nb_jobs;
158 54 const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
159 54 const uint8_t *srcg = in->data[0] + slice_start * in->linesize[0];
160 54 const uint8_t *srcb = in->data[1] + slice_start * in->linesize[1];
161 54 const uint8_t *srcr = in->data[2] + slice_start * in->linesize[2];
162 54 const uint8_t *srca = in->data[3] + slice_start * in->linesize[3];
163 54 uint8_t *dstg = out->data[0] + slice_start * out->linesize[0];
164 54 uint8_t *dstb = out->data[1] + slice_start * out->linesize[1];
165 54 uint8_t *dstr = out->data[2] + slice_start * out->linesize[2];
166 54 uint8_t *dsta = out->data[3] + slice_start * out->linesize[3];
167 54 const float max = s->max;
168 int i, j;
169
170
2/2
✓ Branch 0 taken 1728 times.
✓ Branch 1 taken 54 times.
 1782 for (i = slice_start; i < slice_end; i++) {
171
2/2
✓ Branch 0 taken 608256 times.
✓ Branch 1 taken 1728 times.
 609984 for (j = 0; j < out->width; j++) {
172 608256 float r = srcr[j] / max;
173 608256 float g = srcg[j] / max;
174 608256 float b = srcb[j] / max;
175
12/12
✓ Branch 0 taken 312912 times.
✓ Branch 1 taken 295344 times.
✓ Branch 2 taken 374872 times.
✓ Branch 3 taken 233384 times.
✓ Branch 4 taken 208942 times.
✓ Branch 5 taken 165930 times.
✓ Branch 6 taken 312912 times.
✓ Branch 7 taken 295344 times.
✓ Branch 8 taken 187642 times.
✓ Branch 9 taken 420614 times.
✓ Branch 10 taken 208944 times.
✓ Branch 11 taken 211670 times.
 608256 const float l = FFMAX3(r, g, b) + FFMIN3(r, g, b);
176
177 608256 r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
178 608256 g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
179 608256 b = get_component(b, l, s->yellow_blue.shadows, s->yellow_blue.midtones, s->yellow_blue.highlights);
180
181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 608256 times.
 608256 if (s->preserve_lightness)
182 ✗ preservel(&r, &g, &b, l);
183
184 608256 dstr[j] = av_clip_uint8(lrintf(r * max));
185 608256 dstg[j] = av_clip_uint8(lrintf(g * max));
186 608256 dstb[j] = av_clip_uint8(lrintf(b * max));
187
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 608256 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 608256 if (in != out && out->linesize[3])
188 ✗ dsta[j] = srca[j];
189 }
190
191 1728 srcg += in->linesize[0];
192 1728 srcb += in->linesize[1];
193 1728 srcr += in->linesize[2];
194 1728 srca += in->linesize[3];
195 1728 dstg += out->linesize[0];
196 1728 dstb += out->linesize[1];
197 1728 dstr += out->linesize[2];
198 1728 dsta += out->linesize[3];
199 }
200
201 54 return 0;
202 }
203
204 ✗ static int color_balance16_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
205 {
206 ✗ ColorBalanceContext *s = ctx->priv;
207 ✗ ThreadData *td = arg;
208 ✗ AVFrame *in = td->in;
209 ✗ AVFrame *out = td->out;
210 ✗ const int slice_start = (out->height * jobnr) / nb_jobs;
211 ✗ const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
212 ✗ const uint16_t *srcg = (const uint16_t *)in->data[0] + slice_start * in->linesize[0] / 2;
213 ✗ const uint16_t *srcb = (const uint16_t *)in->data[1] + slice_start * in->linesize[1] / 2;
214 ✗ const uint16_t *srcr = (const uint16_t *)in->data[2] + slice_start * in->linesize[2] / 2;
215 ✗ const uint16_t *srca = (const uint16_t *)in->data[3] + slice_start * in->linesize[3] / 2;
216 ✗ uint16_t *dstg = (uint16_t *)out->data[0] + slice_start * out->linesize[0] / 2;
217 ✗ uint16_t *dstb = (uint16_t *)out->data[1] + slice_start * out->linesize[1] / 2;
218 ✗ uint16_t *dstr = (uint16_t *)out->data[2] + slice_start * out->linesize[2] / 2;
219 ✗ uint16_t *dsta = (uint16_t *)out->data[3] + slice_start * out->linesize[3] / 2;
220 ✗ const int depth = s->depth;
221 ✗ const float max = s->max;
222 int i, j;
223
224 ✗ for (i = slice_start; i < slice_end; i++) {
225 ✗ for (j = 0; j < out->width; j++) {
226 ✗ float r = srcr[j] / max;
227 ✗ float g = srcg[j] / max;
228 ✗ float b = srcb[j] / max;
229 ✗ const float l = (FFMAX3(r, g, b) + FFMIN3(r, g, b));
230
231 ✗ r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
232 ✗ g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
233 ✗ b = get_component(b, l, s->yellow_blue.shadows, s->yellow_blue.midtones, s->yellow_blue.highlights);
234
235 ✗ if (s->preserve_lightness)
236 ✗ preservel(&r, &g, &b, l);
237
238 ✗ dstr[j] = av_clip_uintp2_c(lrintf(r * max), depth);
239 ✗ dstg[j] = av_clip_uintp2_c(lrintf(g * max), depth);
240 ✗ dstb[j] = av_clip_uintp2_c(lrintf(b * max), depth);
241 ✗ if (in != out && out->linesize[3])
242 ✗ dsta[j] = srca[j];
243 }
244
245 ✗ srcg += in->linesize[0] / 2;
246 ✗ srcb += in->linesize[1] / 2;
247 ✗ srcr += in->linesize[2] / 2;
248 ✗ srca += in->linesize[3] / 2;
249 ✗ dstg += out->linesize[0] / 2;
250 ✗ dstb += out->linesize[1] / 2;
251 ✗ dstr += out->linesize[2] / 2;
252 ✗ dsta += out->linesize[3] / 2;
253 }
254
255 ✗ return 0;
256 }
257
258 27 static int color_balance8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
259 {
260 27 ColorBalanceContext *s = ctx->priv;
261 27 ThreadData *td = arg;
262 27 AVFrame *in = td->in;
263 27 AVFrame *out = td->out;
264 27 AVFilterLink *outlink = ctx->outputs[0];
265 27 const int slice_start = (out->height * jobnr) / nb_jobs;
266 27 const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
267 27 const uint8_t *srcrow = in->data[0] + slice_start * in->linesize[0];
268 27 const uint8_t roffset = s->rgba_map[R];
269 27 const uint8_t goffset = s->rgba_map[G];
270 27 const uint8_t boffset = s->rgba_map[B];
271 27 const uint8_t aoffset = s->rgba_map[A];
272 27 const float max = s->max;
273 27 const int step = s->step;
274 uint8_t *dstrow;
275 int i, j;
276
277 27 dstrow = out->data[0] + slice_start * out->linesize[0];
278
2/2
✓ Branch 0 taken 864 times.
✓ Branch 1 taken 27 times.
 891 for (i = slice_start; i < slice_end; i++) {
279 864 const uint8_t *src = srcrow;
280 864 uint8_t *dst = dstrow;
281
282
2/2
✓ Branch 0 taken 304128 times.
✓ Branch 1 taken 864 times.
 304992 for (j = 0; j < outlink->w * step; j += step) {
283 304128 float r = src[j + roffset] / max;
284 304128 float g = src[j + goffset] / max;
285 304128 float b = src[j + boffset] / max;
286
12/12
✓ Branch 0 taken 155828 times.
✓ Branch 1 taken 148300 times.
✓ Branch 2 taken 187165 times.
✓ Branch 3 taken 116963 times.
✓ Branch 4 taken 103585 times.
✓ Branch 5 taken 83580 times.
✓ Branch 6 taken 155828 times.
✓ Branch 7 taken 148300 times.
✓ Branch 8 taken 95009 times.
✓ Branch 9 taken 209119 times.
✓ Branch 10 taken 103145 times.
✓ Branch 11 taken 105974 times.
 304128 const float l = (FFMAX3(r, g, b) + FFMIN3(r, g, b));
287
288 304128 r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
289 304128 g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
290 304128 b = get_component(b, l, s->yellow_blue.shadows, s->yellow_blue.midtones, s->yellow_blue.highlights);
291
292
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 304128 times.
 304128 if (s->preserve_lightness)
293 ✗ preservel(&r, &g, &b, l);
294
295 304128 dst[j + roffset] = av_clip_uint8(lrintf(r * max));
296 304128 dst[j + goffset] = av_clip_uint8(lrintf(g * max));
297 304128 dst[j + boffset] = av_clip_uint8(lrintf(b * max));
298
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 304128 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 304128 if (in != out && step == 4)
299 ✗ dst[j + aoffset] = src[j + aoffset];
300 }
301
302 864 srcrow += in->linesize[0];
303 864 dstrow += out->linesize[0];
304 }
305
306 27 return 0;
307 }
308
309 27 static int color_balance16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
310 {
311 27 ColorBalanceContext *s = ctx->priv;
312 27 ThreadData *td = arg;
313 27 AVFrame *in = td->in;
314 27 AVFrame *out = td->out;
315 27 AVFilterLink *outlink = ctx->outputs[0];
316 27 const int slice_start = (out->height * jobnr) / nb_jobs;
317 27 const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
318 27 const uint16_t *srcrow = (const uint16_t *)in->data[0] + slice_start * in->linesize[0] / 2;
319 27 const uint8_t roffset = s->rgba_map[R];
320 27 const uint8_t goffset = s->rgba_map[G];
321 27 const uint8_t boffset = s->rgba_map[B];
322 27 const uint8_t aoffset = s->rgba_map[A];
323 27 const int step = s->step / 2;
324 27 const int depth = s->depth;
325 27 const float max = s->max;
326 uint16_t *dstrow;
327 int i, j;
328
329 27 dstrow = (uint16_t *)out->data[0] + slice_start * out->linesize[0] / 2;
330
2/2
✓ Branch 0 taken 864 times.
✓ Branch 1 taken 27 times.
 891 for (i = slice_start; i < slice_end; i++) {
331 864 const uint16_t *src = srcrow;
332 864 uint16_t *dst = dstrow;
333
334
2/2
✓ Branch 0 taken 304128 times.
✓ Branch 1 taken 864 times.
 304992 for (j = 0; j < outlink->w * step; j += step) {
335 304128 float r = src[j + roffset] / max;
336 304128 float g = src[j + goffset] / max;
337 304128 float b = src[j + boffset] / max;
338
12/12
✓ Branch 0 taken 157356 times.
✓ Branch 1 taken 146772 times.
✓ Branch 2 taken 187897 times.
✓ Branch 3 taken 116231 times.
✓ Branch 4 taken 104666 times.
✓ Branch 5 taken 83231 times.
✓ Branch 6 taken 157356 times.
✓ Branch 7 taken 146772 times.
✓ Branch 8 taken 95819 times.
✓ Branch 9 taken 208309 times.
✓ Branch 10 taken 103860 times.
✓ Branch 11 taken 104449 times.
 304128 const float l = (FFMAX3(r, g, b) + FFMIN3(r, g, b));
339
340 304128 r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
341 304128 g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
342 304128 b = get_component(b, l, s->yellow_blue.shadows, s->yellow_blue.midtones, s->yellow_blue.highlights);
343
344
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 304128 times.
 304128 if (s->preserve_lightness)
345 ✗ preservel(&r, &g, &b, l);
346
347 304128 dst[j + roffset] = av_clip_uintp2_c(lrintf(r * max), depth);
348 304128 dst[j + goffset] = av_clip_uintp2_c(lrintf(g * max), depth);
349 304128 dst[j + boffset] = av_clip_uintp2_c(lrintf(b * max), depth);
350
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 304128 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 304128 if (in != out && step == 4)
351 ✗ dst[j + aoffset] = src[j + aoffset];
352 }
353
354 864 srcrow += in->linesize[0] / 2;
355 864 dstrow += out->linesize[0] / 2;
356 }
357
358 27 return 0;
359 }
360
361 4 static int config_output(AVFilterLink *outlink)
362 {
363 4 AVFilterContext *ctx = outlink->src;
364 4 ColorBalanceContext *s = ctx->priv;
365 4 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
366 4 const int depth = desc->comp[0].depth;
367 4 const int max = (1 << depth) - 1;
368 4 const int planar = av_pix_fmt_count_planes(outlink->format) > 1;
369
370 4 s->depth = depth;
371 4 s->max = max;
372
373
4/4
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
 4 if (max == 255 && planar) {
374 2 s->color_balance = color_balance8_p;
375
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 } else if (planar) {
376 ✗ s->color_balance = color_balance16_p;
377
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 } else if (max == 255) {
378 1 s->color_balance = color_balance8;
379 } else {
380 1 s->color_balance = color_balance16;
381 }
382
383 4 ff_fill_rgba_map(s->rgba_map, outlink->format);
384 4 s->step = av_get_padded_bits_per_pixel(desc) >> 3;
385
386 4 return 0;
387 }
388
389 12 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
390 {
391 12 AVFilterContext *ctx = inlink->dst;
392 12 ColorBalanceContext *s = ctx->priv;
393 12 AVFilterLink *outlink = ctx->outputs[0];
394 ThreadData td;
395 AVFrame *out;
396
397
1/2
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
 12 if (av_frame_is_writable(in)) {
398 12 out = in;
399 } else {
400 ✗ out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
401 ✗ if (!out) {
402 ✗ av_frame_free(&in);
403 ✗ return AVERROR(ENOMEM);
404 }
405 ✗ av_frame_copy_props(out, in);
406 }
407
408 12 td.in = in;
409 12 td.out = out;
410 12 ff_filter_execute(ctx, s->color_balance, &td, NULL,
411
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
412
413
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 if (in != out)
414 ✗ av_frame_free(&in);
415 12 return ff_filter_frame(outlink, out);
416 }
417
418 static const AVFilterPad colorbalance_inputs[] = {
419 {
420 .name = "default",
421 .type = AVMEDIA_TYPE_VIDEO,
422 .filter_frame = filter_frame,
423 },
424 };
425
426 static const AVFilterPad colorbalance_outputs[] = {
427 {
428 .name = "default",
429 .type = AVMEDIA_TYPE_VIDEO,
430 .config_props = config_output,
431 },
432 };
433
434 const AVFilter ff_vf_colorbalance = {
435 .name = "colorbalance",
436 .description = NULL_IF_CONFIG_SMALL("Adjust the color balance."),
437 .priv_size = sizeof(ColorBalanceContext),
438 .priv_class = &colorbalance_class,
439 FILTER_INPUTS(colorbalance_inputs),
440 FILTER_OUTPUTS(colorbalance_outputs),
441 FILTER_PIXFMTS_ARRAY(pix_fmts),
442 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
443 .process_command = ff_filter_process_command,
444 };
445