FFmpeg
vf_lut.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
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 /**
22  * @file
23  * Compute a look-up table for binding the input value to the output
24  * value, and apply it to input video.
25  */
26 
27 #include "config_components.h"
28 
29 #include "libavutil/attributes.h"
30 #include "libavutil/bswap.h"
31 #include "libavutil/common.h"
32 #include "libavutil/eval.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 #include "avfilter.h"
37 #include "drawutils.h"
38 #include "formats.h"
39 #include "internal.h"
40 #include "video.h"
41 
42 static const char *const var_names[] = {
43  "w", ///< width of the input video
44  "h", ///< height of the input video
45  "val", ///< input value for the pixel
46  "maxval", ///< max value for the pixel
47  "minval", ///< min value for the pixel
48  "negval", ///< negated value
49  "clipval",
50  NULL
51 };
52 
53 enum var_name {
54  VAR_W,
55  VAR_H,
56  VAR_VAL,
57  VAR_MAXVAL,
58  VAR_MINVAL,
59  VAR_NEGVAL,
60  VAR_CLIPVAL,
61  VAR_VARS_NB
62 };
63 
64 typedef struct LutContext {
65  const AVClass *class;
66  uint16_t lut[4][256 * 256]; ///< lookup table for each component
67  char *comp_expr_str[4];
68  AVExpr *comp_expr[4];
69  int hsub, vsub;
70  double var_values[VAR_VARS_NB];
71  int is_rgb, is_yuv;
72  int is_planar;
73  int is_16bit;
74  int step;
75 } LutContext;
76 
77 #define Y 0
78 #define U 1
79 #define V 2
80 #define R 0
81 #define G 1
82 #define B 2
83 #define A 3
84 
85 #define OFFSET(x) offsetof(LutContext, x)
86 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
87 
88 static const AVOption options[] = {
89  { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
90  { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
91  { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
92  { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
93  { "y", "set Y expression", OFFSET(comp_expr_str[Y]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
94  { "u", "set U expression", OFFSET(comp_expr_str[U]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
95  { "v", "set V expression", OFFSET(comp_expr_str[V]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
96  { "r", "set R expression", OFFSET(comp_expr_str[R]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
97  { "g", "set G expression", OFFSET(comp_expr_str[G]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
98  { "b", "set B expression", OFFSET(comp_expr_str[B]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
99  { "a", "set A expression", OFFSET(comp_expr_str[A]), AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
100  { NULL }
101 };
102 
103 static av_cold void uninit(AVFilterContext *ctx)
104 {
105  LutContext *s = ctx->priv;
106  int i;
107 
108  for (i = 0; i < 4; i++) {
109  av_expr_free(s->comp_expr[i]);
110  s->comp_expr[i] = NULL;
111  av_freep(&s->comp_expr_str[i]);
112  }
113 }
114 
115 #define YUV_FORMATS \
116  AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, \
117  AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P, \
118  AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P, \
119  AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, \
120  AV_PIX_FMT_YUVJ440P, \
121  AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUV422P9LE, AV_PIX_FMT_YUV420P9LE, \
122  AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUV440P10LE, \
123  AV_PIX_FMT_YUV444P12LE, AV_PIX_FMT_YUV422P12LE, AV_PIX_FMT_YUV420P12LE, AV_PIX_FMT_YUV440P12LE, \
124  AV_PIX_FMT_YUV444P14LE, AV_PIX_FMT_YUV422P14LE, AV_PIX_FMT_YUV420P14LE, \
125  AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUV422P16LE, AV_PIX_FMT_YUV420P16LE, \
126  AV_PIX_FMT_YUVA444P16LE, AV_PIX_FMT_YUVA422P16LE, AV_PIX_FMT_YUVA420P16LE
127 
128 #define RGB_FORMATS \
129  AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, \
130  AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA, \
131  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, \
132  AV_PIX_FMT_RGB48LE, AV_PIX_FMT_RGBA64LE, \
133  AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, \
134  AV_PIX_FMT_GBRP9LE, AV_PIX_FMT_GBRP10LE, \
135  AV_PIX_FMT_GBRAP10LE, \
136  AV_PIX_FMT_GBRP12LE, AV_PIX_FMT_GBRP14LE, \
137  AV_PIX_FMT_GBRP16LE, AV_PIX_FMT_GBRAP12LE, \
138  AV_PIX_FMT_GBRAP16LE
139 
140 #define GRAY_FORMATS \
141  AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9LE, AV_PIX_FMT_GRAY10LE, \
142  AV_PIX_FMT_GRAY12LE, AV_PIX_FMT_GRAY14LE, AV_PIX_FMT_GRAY16LE
143 
144 static const enum AVPixelFormat yuv_pix_fmts[] = { YUV_FORMATS, AV_PIX_FMT_NONE };
145 static const enum AVPixelFormat rgb_pix_fmts[] = { RGB_FORMATS, AV_PIX_FMT_NONE };
146 static const enum AVPixelFormat all_pix_fmts[] = { RGB_FORMATS, YUV_FORMATS, GRAY_FORMATS, AV_PIX_FMT_NONE };
147 
148 static int query_formats(AVFilterContext *ctx)
149 {
150  LutContext *s = ctx->priv;
151 
152  const enum AVPixelFormat *pix_fmts = s->is_rgb ? rgb_pix_fmts :
153  s->is_yuv ? yuv_pix_fmts :
154  all_pix_fmts;
155  return ff_set_common_formats_from_list(ctx, pix_fmts);
156 }
157 
158 /**
159  * Clip value val in the minval - maxval range.
160  */
161 static double clip(void *opaque, double val)
162 {
163  LutContext *s = opaque;
164  double minval = s->var_values[VAR_MINVAL];
165  double maxval = s->var_values[VAR_MAXVAL];
166 
167  return av_clip(val, minval, maxval);
168 }
169 
170 /**
171  * Compute gamma correction for value val, assuming the minval-maxval
172  * range, val is clipped to a value contained in the same interval.
173  */
174 static double compute_gammaval(void *opaque, double gamma)
175 {
176  LutContext *s = opaque;
177  double val = s->var_values[VAR_CLIPVAL];
178  double minval = s->var_values[VAR_MINVAL];
179  double maxval = s->var_values[VAR_MAXVAL];
180 
181  return pow((val-minval)/(maxval-minval), gamma) * (maxval-minval)+minval;
182 }
183 
184 /**
185  * Compute ITU Rec.709 gamma correction of value val.
186  */
187 static double compute_gammaval709(void *opaque, double gamma)
188 {
189  LutContext *s = opaque;
190  double val = s->var_values[VAR_CLIPVAL];
191  double minval = s->var_values[VAR_MINVAL];
192  double maxval = s->var_values[VAR_MAXVAL];
193  double level = (val - minval) / (maxval - minval);
194  level = level < 0.018 ? 4.5 * level
195  : 1.099 * pow(level, 1.0 / gamma) - 0.099;
196  return level * (maxval - minval) + minval;
197 }
198 
199 static double (* const funcs1[])(void *, double) = {
200  clip,
201  compute_gammaval,
202  compute_gammaval709,
203  NULL
204 };
205 
206 static const char * const funcs1_names[] = {
207  "clip",
208  "gammaval",
209  "gammaval709",
210  NULL
211 };
212 
213 static int config_props(AVFilterLink *inlink)
214 {
215  AVFilterContext *ctx = inlink->dst;
216  LutContext *s = ctx->priv;
217  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
218  uint8_t rgba_map[4]; /* component index -> RGBA color index map */
219  int min[4], max[4];
220  int val, color, ret;
221 
222  s->hsub = desc->log2_chroma_w;
223  s->vsub = desc->log2_chroma_h;
224 
225  s->var_values[VAR_W] = inlink->w;
226  s->var_values[VAR_H] = inlink->h;
227  s->is_16bit = desc->comp[0].depth > 8;
228 
229  switch (inlink->format) {
230  case AV_PIX_FMT_YUV410P:
231  case AV_PIX_FMT_YUV411P:
232  case AV_PIX_FMT_YUV420P:
233  case AV_PIX_FMT_YUV422P:
234  case AV_PIX_FMT_YUV440P:
235  case AV_PIX_FMT_YUV444P:
236  case AV_PIX_FMT_YUVA420P:
237  case AV_PIX_FMT_YUVA422P:
238  case AV_PIX_FMT_YUVA444P:
239  case AV_PIX_FMT_YUV420P9LE:
240  case AV_PIX_FMT_YUV422P9LE:
241  case AV_PIX_FMT_YUV444P9LE:
242  case AV_PIX_FMT_YUVA420P9LE:
243  case AV_PIX_FMT_YUVA422P9LE:
244  case AV_PIX_FMT_YUVA444P9LE:
245  case AV_PIX_FMT_YUV420P10LE:
246  case AV_PIX_FMT_YUV422P10LE:
247  case AV_PIX_FMT_YUV440P10LE:
248  case AV_PIX_FMT_YUV444P10LE:
249  case AV_PIX_FMT_YUVA420P10LE:
250  case AV_PIX_FMT_YUVA422P10LE:
251  case AV_PIX_FMT_YUVA444P10LE:
252  case AV_PIX_FMT_YUV420P12LE:
253  case AV_PIX_FMT_YUV422P12LE:
254  case AV_PIX_FMT_YUV440P12LE:
255  case AV_PIX_FMT_YUV444P12LE:
256  case AV_PIX_FMT_YUV420P14LE:
257  case AV_PIX_FMT_YUV422P14LE:
258  case AV_PIX_FMT_YUV444P14LE:
259  case AV_PIX_FMT_YUV420P16LE:
260  case AV_PIX_FMT_YUV422P16LE:
261  case AV_PIX_FMT_YUV444P16LE:
262  case AV_PIX_FMT_YUVA420P16LE:
263  case AV_PIX_FMT_YUVA422P16LE:
264  case AV_PIX_FMT_YUVA444P16LE:
265  min[Y] = 16 * (1 << (desc->comp[0].depth - 8));
266  min[U] = 16 * (1 << (desc->comp[1].depth - 8));
267  min[V] = 16 * (1 << (desc->comp[2].depth - 8));
268  min[A] = 0;
269  max[Y] = 235 * (1 << (desc->comp[0].depth - 8));
270  max[U] = 240 * (1 << (desc->comp[1].depth - 8));
271  max[V] = 240 * (1 << (desc->comp[2].depth - 8));
272  max[A] = (1 << desc->comp[0].depth) - 1;
273  break;
274  case AV_PIX_FMT_RGB48LE:
275  case AV_PIX_FMT_RGBA64LE:
276  min[0] = min[1] = min[2] = min[3] = 0;
277  max[0] = max[1] = max[2] = max[3] = 65535;
278  break;
279  default:
280  min[0] = min[1] = min[2] = min[3] = 0;
281  max[0] = max[1] = max[2] = max[3] = 255 * (1 << (desc->comp[0].depth - 8));
282  }
283 
284  s->is_yuv = s->is_rgb = 0;
285  s->is_planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
286  if (ff_fmt_is_in(inlink->format, yuv_pix_fmts)) s->is_yuv = 1;
287  else if (ff_fmt_is_in(inlink->format, rgb_pix_fmts)) s->is_rgb = 1;
288 
289  if (s->is_rgb) {
290  ff_fill_rgba_map(rgba_map, inlink->format);
291  s->step = av_get_bits_per_pixel(desc) >> 3;
292  if (s->is_16bit) {
293  s->step = s->step >> 1;
294  }
295  }
296 
297  for (color = 0; color < desc->nb_components; color++) {
298  double res;
299  int comp = s->is_rgb ? rgba_map[color] : color;
300 
301  /* create the parsed expression */
302  av_expr_free(s->comp_expr[color]);
303  s->comp_expr[color] = NULL;
304  ret = av_expr_parse(&s->comp_expr[color], s->comp_expr_str[color],
305  var_names, funcs1_names, funcs1, NULL, NULL, 0, ctx);
306  if (ret < 0) {
307  av_log(ctx, AV_LOG_ERROR,
308  "Error when parsing the expression '%s' for the component %d and color %d.\n",
309  s->comp_expr_str[comp], comp, color);
310  return AVERROR(EINVAL);
311  }
312 
313  /* compute the lut */
314  s->var_values[VAR_MAXVAL] = max[color];
315  s->var_values[VAR_MINVAL] = min[color];
316 
317  for (val = 0; val < FF_ARRAY_ELEMS(s->lut[comp]); val++) {
318  s->var_values[VAR_VAL] = val;
319  s->var_values[VAR_CLIPVAL] = av_clip(val, min[color], max[color]);
320  s->var_values[VAR_NEGVAL] =
321  av_clip(min[color] + max[color] - s->var_values[VAR_VAL],
322  min[color], max[color]);
323 
324  res = av_expr_eval(s->comp_expr[color], s->var_values, s);
325  if (isnan(res)) {
326  av_log(ctx, AV_LOG_ERROR,
327  "Error when evaluating the expression '%s' for the value %d for the component %d.\n",
328  s->comp_expr_str[color], val, comp);
329  return AVERROR(EINVAL);
330  }
331  s->lut[comp][val] = av_clip((int)res, 0, max[A]);
332  av_log(ctx, AV_LOG_DEBUG, "val[%d][%d] = %d\n", comp, val, s->lut[comp][val]);
333  }
334  }
335 
336  return 0;
337 }
338 
339 struct thread_data {
340  AVFrame *in;
341  AVFrame *out;
342 
343  int w;
344  int h;
345 };
346 
347 #define LOAD_PACKED_COMMON\
348  LutContext *s = ctx->priv;\
349  const struct thread_data *td = arg;\
350 \
351  int i, j;\
352  const int w = td->w;\
353  const int h = td->h;\
354  AVFrame *in = td->in;\
355  AVFrame *out = td->out;\
356  const uint16_t (*tab)[256*256] = (const uint16_t (*)[256*256])s->lut;\
357  const int step = s->step;\
358 \
359  const int slice_start = (h * jobnr ) / nb_jobs;\
360  const int slice_end = (h * (jobnr+1)) / nb_jobs;\
361 
362 /* packed, 16-bit */
363 static int lut_packed_16bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
364 {
365  LOAD_PACKED_COMMON
366 
367  uint16_t *inrow, *outrow, *inrow0, *outrow0;
368  const int in_linesize = in->linesize[0] / 2;
369  const int out_linesize = out->linesize[0] / 2;
370  inrow0 = (uint16_t *)in ->data[0];
371  outrow0 = (uint16_t *)out->data[0];
372 
373  for (i = slice_start; i < slice_end; i++) {
374  inrow = inrow0 + i * in_linesize;
375  outrow = outrow0 + i * out_linesize;
376  for (j = 0; j < w; j++) {
377 
378  switch (step) {
379 #if HAVE_BIGENDIAN
380  case 4: outrow[3] = av_bswap16(tab[3][av_bswap16(inrow[3])]); // Fall-through
381  case 3: outrow[2] = av_bswap16(tab[2][av_bswap16(inrow[2])]); // Fall-through
382  case 2: outrow[1] = av_bswap16(tab[1][av_bswap16(inrow[1])]); // Fall-through
383  default: outrow[0] = av_bswap16(tab[0][av_bswap16(inrow[0])]);
384 #else
385  case 4: outrow[3] = tab[3][inrow[3]]; // Fall-through
386  case 3: outrow[2] = tab[2][inrow[2]]; // Fall-through
387  case 2: outrow[1] = tab[1][inrow[1]]; // Fall-through
388  default: outrow[0] = tab[0][inrow[0]];
389 #endif
390  }
391  outrow += step;
392  inrow += step;
393  }
394  }
395 
396  return 0;
397 }
398 
399 /* packed, 8-bit */
400 static int lut_packed_8bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
401 {
402  LOAD_PACKED_COMMON
403 
404  uint8_t *inrow, *outrow, *inrow0, *outrow0;
405  const int in_linesize = in->linesize[0];
406  const int out_linesize = out->linesize[0];
407  inrow0 = in ->data[0];
408  outrow0 = out->data[0];
409 
410  for (i = slice_start; i < slice_end; i++) {
411  inrow = inrow0 + i * in_linesize;
412  outrow = outrow0 + i * out_linesize;
413  for (j = 0; j < w; j++) {
414  switch (step) {
415  case 4: outrow[3] = tab[3][inrow[3]]; // Fall-through
416  case 3: outrow[2] = tab[2][inrow[2]]; // Fall-through
417  case 2: outrow[1] = tab[1][inrow[1]]; // Fall-through
418  default: outrow[0] = tab[0][inrow[0]];
419  }
420  outrow += step;
421  inrow += step;
422  }
423  }
424 
425  return 0;
426 }
427 
428 #define LOAD_PLANAR_COMMON\
429  LutContext *s = ctx->priv;\
430  const struct thread_data *td = arg;\
431  int i, j, plane;\
432  AVFrame *in = td->in;\
433  AVFrame *out = td->out;\
434 
435 #define PLANAR_COMMON\
436  int vsub = plane == 1 || plane == 2 ? s->vsub : 0;\
437  int hsub = plane == 1 || plane == 2 ? s->hsub : 0;\
438  int h = AV_CEIL_RSHIFT(td->h, vsub);\
439  int w = AV_CEIL_RSHIFT(td->w, hsub);\
440  const uint16_t *tab = s->lut[plane];\
441 \
442  const int slice_start = (h * jobnr ) / nb_jobs;\
443  const int slice_end = (h * (jobnr+1)) / nb_jobs;\
444 
445 /* planar >8 bit depth */
446 static int lut_planar_16bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
447 {
448  LOAD_PLANAR_COMMON
449 
450  uint16_t *inrow, *outrow;
451 
452  for (plane = 0; plane < 4 && in->data[plane] && in->linesize[plane]; plane++) {
453  PLANAR_COMMON
454 
455  const int in_linesize = in->linesize[plane] / 2;
456  const int out_linesize = out->linesize[plane] / 2;
457 
458  inrow = (uint16_t *)in ->data[plane] + slice_start * in_linesize;
459  outrow = (uint16_t *)out->data[plane] + slice_start * out_linesize;
460 
461  for (i = slice_start; i < slice_end; i++) {
462  for (j = 0; j < w; j++) {
463 #if HAVE_BIGENDIAN
464  outrow[j] = av_bswap16(tab[av_bswap16(inrow[j])]);
465 #else
466  outrow[j] = tab[inrow[j]];
467 #endif
468  }
469  inrow += in_linesize;
470  outrow += out_linesize;
471  }
472  }
473 
474  return 0;
475 }
476 
477 /* planar 8bit depth */
478 static int lut_planar_8bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
479 {
480  LOAD_PLANAR_COMMON
481 
482  uint8_t *inrow, *outrow;
483 
484  for (plane = 0; plane < 4 && in->data[plane] && in->linesize[plane]; plane++) {
485  PLANAR_COMMON
486 
487  const int in_linesize = in->linesize[plane];
488  const int out_linesize = out->linesize[plane];
489 
490  inrow = in ->data[plane] + slice_start * in_linesize;
491  outrow = out->data[plane] + slice_start * out_linesize;
492 
493  for (i = slice_start; i < slice_end; i++) {
494  for (j = 0; j < w; j++)
495  outrow[j] = tab[inrow[j]];
496  inrow += in_linesize;
497  outrow += out_linesize;
498  }
499  }
500 
501  return 0;
502 }
503 
504 #define PACKED_THREAD_DATA\
505  struct thread_data td = {\
506  .in = in,\
507  .out = out,\
508  .w = inlink->w,\
509  .h = in->height,\
510  };\
511 
512 #define PLANAR_THREAD_DATA\
513  struct thread_data td = {\
514  .in = in,\
515  .out = out,\
516  .w = inlink->w,\
517  .h = inlink->h,\
518  };\
519 
520 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
521 {
522  AVFilterContext *ctx = inlink->dst;
523  LutContext *s = ctx->priv;
524  AVFilterLink *outlink = ctx->outputs[0];
525  AVFrame *out;
526  int direct = 0;
527 
528  if (av_frame_is_writable(in)) {
529  direct = 1;
530  out = in;
531  } else {
532  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
533  if (!out) {
534  av_frame_free(&in);
535  return AVERROR(ENOMEM);
536  }
537  av_frame_copy_props(out, in);
538  }
539 
540  if (s->is_rgb && s->is_16bit && !s->is_planar) {
541  /* packed, 16-bit */
542  PACKED_THREAD_DATA
543  ff_filter_execute(ctx, lut_packed_16bits, &td, NULL,
544  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
545  } else if (s->is_rgb && !s->is_planar) {
546  /* packed 8 bits */
547  PACKED_THREAD_DATA
548  ff_filter_execute(ctx, lut_packed_8bits, &td, NULL,
549  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
550  } else if (s->is_16bit) {
551  /* planar >8 bit depth */
552  PLANAR_THREAD_DATA
553  ff_filter_execute(ctx, lut_planar_16bits, &td, NULL,
554  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
555  } else {
556  /* planar 8bit depth */
557  PLANAR_THREAD_DATA
558  ff_filter_execute(ctx, lut_planar_8bits, &td, NULL,
559  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
560  }
561 
562  if (!direct)
563  av_frame_free(&in);
564 
565  return ff_filter_frame(outlink, out);
566 }
567 
568 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
569  char *res, int res_len, int flags)
570 {
571  int ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
572 
573  if (ret < 0)
574  return ret;
575 
576  return config_props(ctx->inputs[0]);
577 }
578 
579 static const AVFilterPad inputs[] = {
580  { .name = "default",
581  .type = AVMEDIA_TYPE_VIDEO,
582  .filter_frame = filter_frame,
583  .config_props = config_props,
584  },
585 };
586 
587 #define DEFINE_LUT_FILTER(name_, description_, priv_class_) \
588  const AVFilter ff_vf_##name_ = { \
589  .name = #name_, \
590  .description = NULL_IF_CONFIG_SMALL(description_), \
591  .priv_class = &priv_class_ ## _class, \
592  .priv_size = sizeof(LutContext), \
593  .init = name_##_init, \
594  .uninit = uninit, \
595  FILTER_INPUTS(inputs), \
596  FILTER_OUTPUTS(ff_video_default_filterpad), \
597  FILTER_QUERY_FUNC(query_formats), \
598  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | \
599  AVFILTER_FLAG_SLICE_THREADS, \
600  .process_command = process_command, \
601  }
602 
603 AVFILTER_DEFINE_CLASS_EXT(lut, "lut/lutyuv/lutrgb", options);
604 
605 #if CONFIG_LUT_FILTER
606 
607 #define lut_init NULL
608 DEFINE_LUT_FILTER(lut, "Compute and apply a lookup table to the RGB/YUV input video.",
609  lut);
610 #undef lut_init
611 #endif
612 
613 #if CONFIG_LUTYUV_FILTER
614 
615 static av_cold int lutyuv_init(AVFilterContext *ctx)
616 {
617  LutContext *s = ctx->priv;
618 
619  s->is_yuv = 1;
620 
621  return 0;
622 }
623 
624 DEFINE_LUT_FILTER(lutyuv, "Compute and apply a lookup table to the YUV input video.",
625  lut);
626 #endif
627 
628 #if CONFIG_LUTRGB_FILTER
629 
630 static av_cold int lutrgb_init(AVFilterContext *ctx)
631 {
632  LutContext *s = ctx->priv;
633 
634  s->is_rgb = 1;
635 
636  return 0;
637 }
638 
639 DEFINE_LUT_FILTER(lutrgb, "Compute and apply a lookup table to the RGB input video.",
640  lut);
641 #endif
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(lut, "lut/lutyuv/lutrgb", options)
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:112
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:154
A
#define A
Definition: vf_lut.c:83
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:205
av_clip
#define av_clip
Definition: common.h:99
G
#define G
Definition: vf_lut.c:81
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
var_name
var_name
Definition: noise.c:47
LutContext::is_yuv
int is_yuv
Definition: vf_lut.c:71
compute_gammaval709
static double compute_gammaval709(void *opaque, double gamma)
Compute ITU Rec.709 gamma correction of value val.
Definition: vf_lut.c:187
GRAY_FORMATS
#define GRAY_FORMATS
Definition: vf_lut.c:140
PLANAR_COMMON
#define PLANAR_COMMON
Definition: vf_lut.c:435
out
FILE * out
Definition: movenc.c:55
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_lut.c:520
color
Definition: vf_paletteuse.c:512
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AV_PIX_FMT_YUV422P14LE
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:274
options
static const AVOption options[]
Definition: vf_lut.c:88
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
VAR_W
@ VAR_W
Definition: vf_lut.c:54
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
pixdesc.h
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
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:346
B
#define B
Definition: vf_lut.c:82
data
const char data[16]
Definition: mxf.c:148
LutContext::comp_expr_str
char * comp_expr_str[4]
Definition: vf_lut.c:67
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:128
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2917
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
max
#define max(a, b)
Definition: cuda_runtime.h:33
thread_data::w
int w
Definition: vf_lut.c:343
video.h
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:132
formats.h
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:710
yuv_pix_fmts
static enum AVPixelFormat yuv_pix_fmts[]
Definition: vf_lut.c:144
VAR_H
@ VAR_H
Definition: vf_lut.c:55
LutContext::is_16bit
int is_16bit
Definition: vf_lut.c:73
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:268
var_names
static const char *const var_names[]
Definition: vf_lut.c:42
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
PACKED_THREAD_DATA
#define PACKED_THREAD_DATA
Definition: vf_lut.c:504
val
static double val(void *priv, double ch)
Definition: aeval.c:78
LOAD_PACKED_COMMON
#define LOAD_PACKED_COMMON
Definition: vf_lut.c:347
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
funcs1_names
static const char *const funcs1_names[]
Definition: vf_lut.c:206
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:156
LutContext::lut
uint16_t lut[4][256 *256]
lookup table for each component
Definition: vf_lut.c:66
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:276
AV_PIX_FMT_YUV444P14LE
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:278
LutContext
Definition: vf_lut.c:64
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
thread_data
Definition: vf_lut.c:339
funcs1
static double(*const funcs1[])(void *, double)
Definition: vf_lut.c:199
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
R
#define R
Definition: vf_lut.c:80
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:1730
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:874
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
all_pix_fmts
static enum AVPixelFormat all_pix_fmts[]
Definition: vf_lut.c:146
AVExpr
Definition: eval.c:158
YUV_FORMATS
#define YUV_FORMATS
Definition: vf_lut.c:115
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
PLANAR_THREAD_DATA
#define PLANAR_THREAD_DATA
Definition: vf_lut.c:512
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:162
U
#define U
Definition: vf_lut.c:78
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:184
if
if(ret)
Definition: filter_design.txt:179
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:130
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
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:709
isnan
#define isnan(x)
Definition: libm.h:340
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:110
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:203
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:180
ff_fmt_is_in
int ff_fmt_is_in(int fmt, const int *fmts)
Tell if an integer is contained in the provided -1-terminated list of integers.
Definition: formats.c:407
double
double
Definition: af_crystalizer.c:131
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:188
AV_PIX_FMT_YUV440P10LE
@ AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:298
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:176
lut_packed_8bits
static int lut_packed_8bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_lut.c:400
AV_PIX_FMT_YUV420P14LE
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:270
thread_data::h
int h
Definition: vf_lut.c:344
eval.h
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_lut.c:568
AV_PIX_FMT_YUV440P12LE
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:300
OFFSET
#define OFFSET(x)
Definition: vf_lut.c:85
lut_planar_8bits
static int lut_planar_8bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_lut.c:478
LutContext::var_values
double var_values[VAR_VARS_NB]
Definition: vf_lut.c:70
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:158
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
LutContext::hsub
int hsub
Definition: vf_lut.c:69
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
VAR_MAXVAL
@ VAR_MAXVAL
Definition: vf_lut.c:57
VAR_VAL
@ VAR_VAL
Definition: vf_lut.c:56
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:645
LutContext::comp_expr
AVExpr * comp_expr[4]
Definition: vf_lut.c:68
LutContext::step
int step
Definition: vf_lut.c:74
LOAD_PLANAR_COMMON
#define LOAD_PLANAR_COMMON
Definition: vf_lut.c:428
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:887
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
lut_packed_16bits
static int lut_packed_16bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_lut.c:363
attributes.h
rgb_pix_fmts
static enum AVPixelFormat rgb_pix_fmts[]
Definition: vf_lut.c:145
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:182
internal.h
VAR_CLIPVAL
@ VAR_CLIPVAL
Definition: vf_lut.c:60
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
common.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:827
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
inputs
static const AVFilterPad inputs[]
Definition: vf_lut.c:579
ret
ret
Definition: filter_design.txt:187
bswap.h
LutContext::is_rgb
int is_rgb
Definition: vf_lut.c:71
VAR_NEGVAL
@ VAR_NEGVAL
Definition: vf_lut.c:59
AVFrame::height
int height
Definition: frame.h:446
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
LutContext::vsub
int vsub
Definition: vf_lut.c:69
avfilter.h
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:160
slice_start
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
Definition: dec.c:688
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_lut.c:148
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
V
#define V
Definition: vf_lut.c:79
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
VAR_MINVAL
@ VAR_MINVAL
Definition: vf_lut.c:58
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:186
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
ff_fill_rgba_map
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
LutContext::is_planar
int is_planar
Definition: vf_lut.c:72
thread_data::in
AVFrame * in
Definition: vf_lut.c:340
AV_PIX_FMT_YUV422P9LE
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:164
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:190
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
thread_data::out
AVFrame * out
Definition: vf_lut.c:341
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
config_props
static int config_props(AVFilterLink *inlink)
Definition: vf_lut.c:213
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:192
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
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:134
av_bswap16
#define av_bswap16
Definition: bswap.h:27
lut_planar_16bits
static int lut_planar_16bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_lut.c:446
RGB_FORMATS
#define RGB_FORMATS
Definition: vf_lut.c:128
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:272
FLAGS
#define FLAGS
Definition: vf_lut.c:86
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_lut.c:103
clip
static double clip(void *opaque, double val)
Clip value val in the minval - maxval range.
Definition: vf_lut.c:161
compute_gammaval
static double compute_gammaval(void *opaque, double gamma)
Compute gamma correction for value val, assuming the minval-maxval range, val is clipped to a value c...
Definition: vf_lut.c:174
DEFINE_LUT_FILTER
#define DEFINE_LUT_FILTER(name_, description_, priv_class_)
Definition: vf_lut.c:587
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
VAR_VARS_NB
@ VAR_VARS_NB
Definition: vf_lut.c:61
Y
#define Y
Definition: vf_lut.c:77
min
float min
Definition: vorbis_enc_data.h:429
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:178
Generated on Fri Apr 19 2024 19:22:30 for FFmpeg by   doxygen 1.8.17