FFmpeg: libavfilter/vf_lut.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /