FFmpeg coverage

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