FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavfilter/vf_colorbalance.c
Date: 2026-05-01 13:04:54
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 4866048 static float get_component(float v, float l,
94 float s, float m, float h)
95 {
96 4866048 const float a = 4.f, b = 0.333f, scale = 0.7f;
97
98 4866048 s *= av_clipf((b - l) * a + 0.5f, 0.f, 1.f) * scale;
99 4866048 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 4866048 h *= av_clipf((l + b - 1) * a + 0.5f, 0.f, 1.f) * scale;
101
102 4866048 v += s;
103 4866048 v += m;
104 4866048 v += h;
105
106 4866048 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 72 static int color_balance8_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
151 {
152 72 ColorBalanceContext *s = ctx->priv;
153 72 ThreadData *td = arg;
154 72 AVFrame *in = td->in;
155 72 AVFrame *out = td->out;
156 72 const int slice_start = (out->height * jobnr) / nb_jobs;
157 72 const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
158 72 const uint8_t *srcg = in->data[0] + slice_start * in->linesize[0];
159 72 const uint8_t *srcb = in->data[1] + slice_start * in->linesize[1];
160 72 const uint8_t *srcr = in->data[2] + slice_start * in->linesize[2];
161 72 const uint8_t *srca = in->data[3] + slice_start * in->linesize[3];
162 72 uint8_t *dstg = out->data[0] + slice_start * out->linesize[0];
163 72 uint8_t *dstb = out->data[1] + slice_start * out->linesize[1];
164 72 uint8_t *dstr = out->data[2] + slice_start * out->linesize[2];
165 72 uint8_t *dsta = out->data[3] + slice_start * out->linesize[3];
166 72 const float max = s->max;
167 int i, j;
168
169
2/2
✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 72 times.
 2376 for (i = slice_start; i < slice_end; i++) {
170
2/2
✓ Branch 0 taken 811008 times.
✓ Branch 1 taken 2304 times.
 813312 for (j = 0; j < out->width; j++) {
171 811008 float r = srcr[j] / max;
172 811008 float g = srcg[j] / max;
173 811008 float b = srcb[j] / max;
174
12/12
✓ Branch 0 taken 416810 times.
✓ Branch 1 taken 394198 times.
✓ Branch 2 taken 503116 times.
✓ Branch 3 taken 307892 times.
✓ Branch 4 taken 280056 times.
✓ Branch 5 taken 223060 times.
✓ Branch 6 taken 416810 times.
✓ Branch 7 taken 394198 times.
✓ Branch 8 taken 251852 times.
✓ Branch 9 taken 559156 times.
✓ Branch 10 taken 278122 times.
✓ Branch 11 taken 281034 times.
 811008 const float l = FFMAX3(r, g, b) + FFMIN3(r, g, b);
175
176 811008 r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
177 811008 g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
178 811008 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 811008 times.
 811008 if (s->preserve_lightness)
181 ✗ preservel(&r, &g, &b, l);
182
183 811008 dstr[j] = av_clip_uint8(lrintf(r * max));
184 811008 dstg[j] = av_clip_uint8(lrintf(g * max));
185 811008 dstb[j] = av_clip_uint8(lrintf(b * max));
186
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 811008 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 811008 if (in != out && out->linesize[3])
187 ✗ dsta[j] = srca[j];
188 }
189
190 2304 srcg += in->linesize[0];
191 2304 srcb += in->linesize[1];
192 2304 srcr += in->linesize[2];
193 2304 srca += in->linesize[3];
194 2304 dstg += out->linesize[0];
195 2304 dstb += out->linesize[1];
196 2304 dstr += out->linesize[2];
197 2304 dsta += out->linesize[3];
198 }
199
200 72 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 36 static int color_balance8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
258 {
259 36 ColorBalanceContext *s = ctx->priv;
260 36 ThreadData *td = arg;
261 36 AVFrame *in = td->in;
262 36 AVFrame *out = td->out;
263 36 AVFilterLink *outlink = ctx->outputs[0];
264 36 const int slice_start = (out->height * jobnr) / nb_jobs;
265 36 const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
266 36 const uint8_t *srcrow = in->data[0] + slice_start * in->linesize[0];
267 36 const uint8_t roffset = s->rgba_map[R];
268 36 const uint8_t goffset = s->rgba_map[G];
269 36 const uint8_t boffset = s->rgba_map[B];
270 36 const uint8_t aoffset = s->rgba_map[A];
271 36 const float max = s->max;
272 36 const int step = s->step;
273 uint8_t *dstrow;
274 int i, j;
275
276 36 dstrow = out->data[0] + slice_start * out->linesize[0];
277
2/2
✓ Branch 0 taken 1152 times.
✓ Branch 1 taken 36 times.
 1188 for (i = slice_start; i < slice_end; i++) {
278 1152 const uint8_t *src = srcrow;
279 1152 uint8_t *dst = dstrow;
280
281
2/2
✓ Branch 0 taken 405504 times.
✓ Branch 1 taken 1152 times.
 406656 for (j = 0; j < outlink->w * step; j += step) {
282 405504 float r = src[j + roffset] / max;
283 405504 float g = src[j + goffset] / max;
284 405504 float b = src[j + boffset] / max;
285
12/12
✓ Branch 0 taken 207568 times.
✓ Branch 1 taken 197936 times.
✓ Branch 2 taken 251262 times.
✓ Branch 3 taken 154242 times.
✓ Branch 4 taken 138899 times.
✓ Branch 5 taken 112363 times.
✓ Branch 6 taken 207568 times.
✓ Branch 7 taken 197936 times.
✓ Branch 8 taken 127479 times.
✓ Branch 9 taken 278025 times.
✓ Branch 10 taken 137281 times.
✓ Branch 11 taken 140744 times.
 405504 const float l = (FFMAX3(r, g, b) + FFMIN3(r, g, b));
286
287 405504 r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
288 405504 g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
289 405504 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 405504 times.
 405504 if (s->preserve_lightness)
292 ✗ preservel(&r, &g, &b, l);
293
294 405504 dst[j + roffset] = av_clip_uint8(lrintf(r * max));
295 405504 dst[j + goffset] = av_clip_uint8(lrintf(g * max));
296 405504 dst[j + boffset] = av_clip_uint8(lrintf(b * max));
297
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 405504 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 405504 if (in != out && step == 4)
298 ✗ dst[j + aoffset] = src[j + aoffset];
299 }
300
301 1152 srcrow += in->linesize[0];
302 1152 dstrow += out->linesize[0];
303 }
304
305 36 return 0;
306 }
307
308 36 static int color_balance16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
309 {
310 36 ColorBalanceContext *s = ctx->priv;
311 36 ThreadData *td = arg;
312 36 AVFrame *in = td->in;
313 36 AVFrame *out = td->out;
314 36 AVFilterLink *outlink = ctx->outputs[0];
315 36 const int slice_start = (out->height * jobnr) / nb_jobs;
316 36 const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
317 36 const uint16_t *srcrow = (const uint16_t *)in->data[0] + slice_start * in->linesize[0] / 2;
318 36 const uint8_t roffset = s->rgba_map[R];
319 36 const uint8_t goffset = s->rgba_map[G];
320 36 const uint8_t boffset = s->rgba_map[B];
321 36 const uint8_t aoffset = s->rgba_map[A];
322 36 const int step = s->step / 2;
323 36 const int depth = s->depth;
324 36 const float max = s->max;
325 uint16_t *dstrow;
326 int i, j;
327
328 36 dstrow = (uint16_t *)out->data[0] + slice_start * out->linesize[0] / 2;
329
2/2
✓ Branch 0 taken 1152 times.
✓ Branch 1 taken 36 times.
 1188 for (i = slice_start; i < slice_end; i++) {
330 1152 const uint16_t *src = srcrow;
331 1152 uint16_t *dst = dstrow;
332
333
2/2
✓ Branch 0 taken 405504 times.
✓ Branch 1 taken 1152 times.
 406656 for (j = 0; j < outlink->w * step; j += step) {
334 405504 float r = src[j + roffset] / max;
335 405504 float g = src[j + goffset] / max;
336 405504 float b = src[j + boffset] / max;
337
12/12
✓ Branch 0 taken 209704 times.
✓ Branch 1 taken 195800 times.
✓ Branch 2 taken 252293 times.
✓ Branch 3 taken 153211 times.
✓ Branch 4 taken 140410 times.
✓ Branch 5 taken 111883 times.
✓ Branch 6 taken 209704 times.
✓ Branch 7 taken 195800 times.
✓ Branch 8 taken 128580 times.
✓ Branch 9 taken 276924 times.
✓ Branch 10 taken 138246 times.
✓ Branch 11 taken 138678 times.
 405504 const float l = (FFMAX3(r, g, b) + FFMIN3(r, g, b));
338
339 405504 r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
340 405504 g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
341 405504 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 405504 times.
 405504 if (s->preserve_lightness)
344 ✗ preservel(&r, &g, &b, l);
345
346 405504 dst[j + roffset] = av_clip_uintp2_c(lrintf(r * max), depth);
347 405504 dst[j + goffset] = av_clip_uintp2_c(lrintf(g * max), depth);
348 405504 dst[j + boffset] = av_clip_uintp2_c(lrintf(b * max), depth);
349
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 405504 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 405504 if (in != out && step == 4)
350 ✗ dst[j + aoffset] = src[j + aoffset];
351 }
352
353 1152 srcrow += in->linesize[0] / 2;
354 1152 dstrow += out->linesize[0] / 2;
355 }
356
357 36 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 16 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
389 {
390 16 AVFilterContext *ctx = inlink->dst;
391 16 ColorBalanceContext *s = ctx->priv;
392 16 AVFilterLink *outlink = ctx->outputs[0];
393 ThreadData td;
394 AVFrame *out;
395
396
1/2
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
 16 if (av_frame_is_writable(in)) {
397 16 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 16 td.in = in;
408 16 td.out = out;
409 16 ff_filter_execute(ctx, s->color_balance, &td, NULL,
410
1/2
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
 16 FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
411
412
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (in != out)
413 ✗ av_frame_free(&in);
414 16 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 FFFilter ff_vf_colorbalance = {
434 .p.name = "colorbalance",
435 .p.description = NULL_IF_CONFIG_SMALL("Adjust the color balance."),
436 .p.priv_class = &colorbalance_class,
437 .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
438 .priv_size = sizeof(ColorBalanceContext),
439 FILTER_INPUTS(colorbalance_inputs),
440 FILTER_OUTPUTS(colorbalance_outputs),
441 FILTER_PIXFMTS_ARRAY(pix_fmts),
442 .process_command = ff_filter_process_command,
443 };
444