FFmpeg
vf_colorbalance.c
Go to the documentation of this file.
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 static float get_component(float v, float l,
95  float s, float m, float h)
96 {
97  const float a = 4.f, b = 0.333f, scale = 0.7f;
98 
99  s *= av_clipf((b - l) * a + 0.5f, 0.f, 1.f) * scale;
100  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  h *= av_clipf((l + b - 1) * a + 0.5f, 0.f, 1.f) * scale;
102 
103  v += s;
104  v += m;
105  v += h;
106 
107  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 static int color_balance8_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
152 {
153  ColorBalanceContext *s = ctx->priv;
154  ThreadData *td = arg;
155  AVFrame *in = td->in;
156  AVFrame *out = td->out;
157  const int slice_start = (out->height * jobnr) / nb_jobs;
158  const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
159  const uint8_t *srcg = in->data[0] + slice_start * in->linesize[0];
160  const uint8_t *srcb = in->data[1] + slice_start * in->linesize[1];
161  const uint8_t *srcr = in->data[2] + slice_start * in->linesize[2];
162  const uint8_t *srca = in->data[3] + slice_start * in->linesize[3];
163  uint8_t *dstg = out->data[0] + slice_start * out->linesize[0];
164  uint8_t *dstb = out->data[1] + slice_start * out->linesize[1];
165  uint8_t *dstr = out->data[2] + slice_start * out->linesize[2];
166  uint8_t *dsta = out->data[3] + slice_start * out->linesize[3];
167  const float max = s->max;
168  int i, j;
169 
170  for (i = slice_start; i < slice_end; i++) {
171  for (j = 0; j < out->width; j++) {
172  float r = srcr[j] / max;
173  float g = srcg[j] / max;
174  float b = srcb[j] / max;
175  const float l = FFMAX3(r, g, b) + FFMIN3(r, g, b);
176 
177  r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
178  g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
179  b = get_component(b, l, s->yellow_blue.shadows, s->yellow_blue.midtones, s->yellow_blue.highlights);
180 
181  if (s->preserve_lightness)
182  preservel(&r, &g, &b, l);
183 
184  dstr[j] = av_clip_uint8(lrintf(r * max));
185  dstg[j] = av_clip_uint8(lrintf(g * max));
186  dstb[j] = av_clip_uint8(lrintf(b * max));
187  if (in != out && out->linesize[3])
188  dsta[j] = srca[j];
189  }
190 
191  srcg += in->linesize[0];
192  srcb += in->linesize[1];
193  srcr += in->linesize[2];
194  srca += in->linesize[3];
195  dstg += out->linesize[0];
196  dstb += out->linesize[1];
197  dstr += out->linesize[2];
198  dsta += out->linesize[3];
199  }
200 
201  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 static int color_balance8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
259 {
260  ColorBalanceContext *s = ctx->priv;
261  ThreadData *td = arg;
262  AVFrame *in = td->in;
263  AVFrame *out = td->out;
264  AVFilterLink *outlink = ctx->outputs[0];
265  const int slice_start = (out->height * jobnr) / nb_jobs;
266  const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
267  const uint8_t *srcrow = in->data[0] + slice_start * in->linesize[0];
268  const uint8_t roffset = s->rgba_map[R];
269  const uint8_t goffset = s->rgba_map[G];
270  const uint8_t boffset = s->rgba_map[B];
271  const uint8_t aoffset = s->rgba_map[A];
272  const float max = s->max;
273  const int step = s->step;
274  uint8_t *dstrow;
275  int i, j;
276 
277  dstrow = out->data[0] + slice_start * out->linesize[0];
278  for (i = slice_start; i < slice_end; i++) {
279  const uint8_t *src = srcrow;
280  uint8_t *dst = dstrow;
281 
282  for (j = 0; j < outlink->w * step; j += step) {
283  float r = src[j + roffset] / max;
284  float g = src[j + goffset] / max;
285  float b = src[j + boffset] / max;
286  const float l = (FFMAX3(r, g, b) + FFMIN3(r, g, b));
287 
288  r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
289  g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
290  b = get_component(b, l, s->yellow_blue.shadows, s->yellow_blue.midtones, s->yellow_blue.highlights);
291 
292  if (s->preserve_lightness)
293  preservel(&r, &g, &b, l);
294 
295  dst[j + roffset] = av_clip_uint8(lrintf(r * max));
296  dst[j + goffset] = av_clip_uint8(lrintf(g * max));
297  dst[j + boffset] = av_clip_uint8(lrintf(b * max));
298  if (in != out && step == 4)
299  dst[j + aoffset] = src[j + aoffset];
300  }
301 
302  srcrow += in->linesize[0];
303  dstrow += out->linesize[0];
304  }
305 
306  return 0;
307 }
308 
309 static int color_balance16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
310 {
311  ColorBalanceContext *s = ctx->priv;
312  ThreadData *td = arg;
313  AVFrame *in = td->in;
314  AVFrame *out = td->out;
315  AVFilterLink *outlink = ctx->outputs[0];
316  const int slice_start = (out->height * jobnr) / nb_jobs;
317  const int slice_end = (out->height * (jobnr+1)) / nb_jobs;
318  const uint16_t *srcrow = (const uint16_t *)in->data[0] + slice_start * in->linesize[0] / 2;
319  const uint8_t roffset = s->rgba_map[R];
320  const uint8_t goffset = s->rgba_map[G];
321  const uint8_t boffset = s->rgba_map[B];
322  const uint8_t aoffset = s->rgba_map[A];
323  const int step = s->step / 2;
324  const int depth = s->depth;
325  const float max = s->max;
326  uint16_t *dstrow;
327  int i, j;
328 
329  dstrow = (uint16_t *)out->data[0] + slice_start * out->linesize[0] / 2;
330  for (i = slice_start; i < slice_end; i++) {
331  const uint16_t *src = srcrow;
332  uint16_t *dst = dstrow;
333 
334  for (j = 0; j < outlink->w * step; j += step) {
335  float r = src[j + roffset] / max;
336  float g = src[j + goffset] / max;
337  float b = src[j + boffset] / max;
338  const float l = (FFMAX3(r, g, b) + FFMIN3(r, g, b));
339 
340  r = get_component(r, l, s->cyan_red.shadows, s->cyan_red.midtones, s->cyan_red.highlights);
341  g = get_component(g, l, s->magenta_green.shadows, s->magenta_green.midtones, s->magenta_green.highlights);
342  b = get_component(b, l, s->yellow_blue.shadows, s->yellow_blue.midtones, s->yellow_blue.highlights);
343 
344  if (s->preserve_lightness)
345  preservel(&r, &g, &b, l);
346 
347  dst[j + roffset] = av_clip_uintp2_c(lrintf(r * max), depth);
348  dst[j + goffset] = av_clip_uintp2_c(lrintf(g * max), depth);
349  dst[j + boffset] = av_clip_uintp2_c(lrintf(b * max), depth);
350  if (in != out && step == 4)
351  dst[j + aoffset] = src[j + aoffset];
352  }
353 
354  srcrow += in->linesize[0] / 2;
355  dstrow += out->linesize[0] / 2;
356  }
357 
358  return 0;
359 }
360 
361 static int config_output(AVFilterLink *outlink)
362 {
363  AVFilterContext *ctx = outlink->src;
364  ColorBalanceContext *s = ctx->priv;
365  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
366  const int depth = desc->comp[0].depth;
367  const int max = (1 << depth) - 1;
368  const int planar = av_pix_fmt_count_planes(outlink->format) > 1;
369 
370  s->depth = depth;
371  s->max = max;
372 
373  if (max == 255 && planar) {
374  s->color_balance = color_balance8_p;
375  } else if (planar) {
376  s->color_balance = color_balance16_p;
377  } else if (max == 255) {
378  s->color_balance = color_balance8;
379  } else {
380  s->color_balance = color_balance16;
381  }
382 
383  ff_fill_rgba_map(s->rgba_map, outlink->format);
384  s->step = av_get_padded_bits_per_pixel(desc) >> 3;
385 
386  return 0;
387 }
388 
389 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
390 {
391  AVFilterContext *ctx = inlink->dst;
392  ColorBalanceContext *s = ctx->priv;
393  AVFilterLink *outlink = ctx->outputs[0];
394  ThreadData td;
395  AVFrame *out;
396 
397  if (av_frame_is_writable(in)) {
398  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  td.in = in;
409  td.out = out;
410  ff_filter_execute(ctx, s->color_balance, &td, NULL,
411  FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
412 
413  if (in != out)
414  av_frame_free(&in);
415  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 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:101
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:487
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_colorbalance.c:389
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
colorbalance_outputs
static const AVFilterPad colorbalance_outputs[]
Definition: vf_colorbalance.c:426
r
const char * r
Definition: vf_curves.c:126
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
get_component
static float get_component(float v, float l, float s, float m, float h)
Definition: vf_colorbalance.c:94
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:971
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2936
colorbalance_inputs
static const AVFilterPad colorbalance_inputs[]
Definition: vf_colorbalance.c:418
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:174
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
G
#define G
Definition: vf_colorbalance.c:30
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
ColorBalanceContext::cyan_red
Range cyan_red
Definition: vf_colorbalance.c:46
ColorBalanceContext::color_balance
int(* color_balance)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_colorbalance.c:56
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
pixdesc.h
av_clip_uintp2_c
static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
Clip a signed integer to an unsigned power of two range.
Definition: common.h:275
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:473
video.h
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:154
preservel
static void preservel(float *r, float *g, float *b, float l)
Definition: vf_colorbalance.c:118
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
formats.h
Range::highlights
float highlights
Definition: vf_colorbalance.c:41
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2976
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:483
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
color_balance16_p
static int color_balance16_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_colorbalance.c:204
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:481
ColorBalanceContext
Definition: vf_colorbalance.c:44
ColorBalanceContext::preserve_lightness
int preserve_lightness
Definition: vf_colorbalance.c:49
FLAGS
#define FLAGS
Definition: vf_colorbalance.c:60
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
ColorBalanceContext::step
int step
Definition: vf_colorbalance.c:54
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:485
s
#define s(width, name)
Definition: cbs_vp9.c:256
ColorBalanceContext::rgba_map
uint8_t rgba_map[4]
Definition: vf_colorbalance.c:51
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:486
colorbalance_options
static const AVOption colorbalance_options[]
Definition: vf_colorbalance.c:61
g
const char * g
Definition: vf_curves.c:127
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2020
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:194
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
arg
const char * arg
Definition: jacosubdec.c:67
Range::shadows
float shadows
Definition: vf_colorbalance.c:39
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:484
ColorBalanceContext::yellow_blue
Range yellow_blue
Definition: vf_colorbalance.c:48
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:455
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:456
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
hfun
static float hfun(float n, float h, float s, float l)
Definition: vf_colorbalance.c:110
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(colorbalance)
A
#define A
Definition: vf_colorbalance.c:32
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:258
av_clipf
av_clipf
Definition: af_crystalizer.c:122
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:480
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
R
#define R
Definition: vf_colorbalance.c:29
Range
Definition: vf_colorbalance.c:38
ColorBalanceContext::max
int max
Definition: vf_colorbalance.c:53
f
f
Definition: af_crystalizer.c:122
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:114
av_get_padded_bits_per_pixel
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel for the pixel format described by pixdesc, including any padding ...
Definition: pixdesc.c:2901
color_balance16
static int color_balance16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_colorbalance.c:309
B
#define B
Definition: vf_colorbalance.c:31
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:451
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:666
color_balance8_p
static int color_balance8_p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_colorbalance.c:151
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:844
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:256
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_colorbalance.c:77
ColorBalanceContext::depth
int depth
Definition: vf_colorbalance.c:52
ff_vf_colorbalance
const AVFilter ff_vf_colorbalance
Definition: vf_colorbalance.c:434
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:147
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_colorbalance.c:361
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:460
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
FFMIN3
#define FFMIN3(a, b, c)
Definition: macros.h:50
OFFSET
#define OFFSET(x)
Definition: vf_colorbalance.c:59
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:482
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:779
ThreadData
Used for passing data between threads.
Definition: dsddec.c:69
ColorBalanceContext::magenta_green
Range magenta_green
Definition: vf_colorbalance.c:47
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
color_balance8
static int color_balance8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_colorbalance.c:258
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
AVFilter
Filter definition.
Definition: avfilter.h:166
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:257
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
avfilter.h
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
Range::midtones
float midtones
Definition: vf_colorbalance.c:40
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:195
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
ff_fill_rgba_map
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:375
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:255
h
h
Definition: vp9dsp_template.c:2038
drawutils.h
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:146
int
int
Definition: ffmpeg_filter.c:354
min
float min
Definition: vorbis_enc_data.h:429
Generated on Tue Jun 6 2023 19:21:58 for FFmpeg by   doxygen 1.8.17