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/mem.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 #include "avfilter.h"
37 #include "drawutils.h"
38 #include "filters.h"
39 #include "formats.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(const AVFilterContext *ctx,
149  AVFilterFormatsConfig **cfg_in,
150  AVFilterFormatsConfig **cfg_out)
151 {
152  const LutContext *s = ctx->priv;
153 
154  const enum AVPixelFormat *pix_fmts = s->is_rgb ? rgb_pix_fmts :
155  s->is_yuv ? yuv_pix_fmts :
156  all_pix_fmts;
157  return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
158 }
159 
160 /**
161  * Clip value val in the minval - maxval range.
162  */
163  static double clip(void *opaque, double val)
164 {
165  LutContext *s = opaque;
166  double minval = s->var_values[VAR_MINVAL];
167  double maxval = s->var_values[VAR_MAXVAL];
168 
169  return av_clip(val, minval, maxval);
170 }
171 
172 /**
173  * Compute gamma correction for value val, assuming the minval-maxval
174  * range, val is clipped to a value contained in the same interval.
175  */
176  static double compute_gammaval(void *opaque, double gamma)
177 {
178  LutContext *s = opaque;
179  double val = s->var_values[VAR_CLIPVAL];
180  double minval = s->var_values[VAR_MINVAL];
181  double maxval = s->var_values[VAR_MAXVAL];
182 
183  return pow((val-minval)/(maxval-minval), gamma) * (maxval-minval)+minval;
184 }
185 
186 /**
187  * Compute ITU Rec.709 gamma correction of value val.
188  */
189  static double compute_gammaval709(void *opaque, double gamma)
190 {
191  LutContext *s = opaque;
192  double val = s->var_values[VAR_CLIPVAL];
193  double minval = s->var_values[VAR_MINVAL];
194  double maxval = s->var_values[VAR_MAXVAL];
195  double level = (val - minval) / (maxval - minval);
196  level = level < 0.018 ? 4.5 * level
197  : 1.099 * pow(level, 1.0 / gamma) - 0.099;
198  return level * (maxval - minval) + minval;
199 }
200 
201  static double (* const funcs1[])(void *, double) = {
202  clip,
203  compute_gammaval,
204  compute_gammaval709,
205  NULL
206 };
207 
208  static const char * const funcs1_names[] = {
209  "clip",
210  "gammaval",
211  "gammaval709",
212  NULL
213 };
214 
215  static int config_props(AVFilterLink *inlink)
216 {
217  AVFilterContext *ctx = inlink->dst;
218  LutContext *s = ctx->priv;
219  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
220  uint8_t rgba_map[4]; /* component index -> RGBA color index map */
221  int min[4], max[4];
222  int val, color, ret;
223 
224  s->hsub = desc->log2_chroma_w;
225  s->vsub = desc->log2_chroma_h;
226 
227  s->var_values[VAR_W] = inlink->w;
228  s->var_values[VAR_H] = inlink->h;
229  s->is_16bit = desc->comp[0].depth > 8;
230 
231  switch (inlink->format) {
232  case AV_PIX_FMT_YUV410P:
233  case AV_PIX_FMT_YUV411P:
234  case AV_PIX_FMT_YUV420P:
235  case AV_PIX_FMT_YUV422P:
236  case AV_PIX_FMT_YUV440P:
237  case AV_PIX_FMT_YUV444P:
238  case AV_PIX_FMT_YUVA420P:
239  case AV_PIX_FMT_YUVA422P:
240  case AV_PIX_FMT_YUVA444P:
241  case AV_PIX_FMT_YUV420P9LE:
242  case AV_PIX_FMT_YUV422P9LE:
243  case AV_PIX_FMT_YUV444P9LE:
244  case AV_PIX_FMT_YUVA420P9LE:
245  case AV_PIX_FMT_YUVA422P9LE:
246  case AV_PIX_FMT_YUVA444P9LE:
247  case AV_PIX_FMT_YUV420P10LE:
248  case AV_PIX_FMT_YUV422P10LE:
249  case AV_PIX_FMT_YUV440P10LE:
250  case AV_PIX_FMT_YUV444P10LE:
251  case AV_PIX_FMT_YUVA420P10LE:
252  case AV_PIX_FMT_YUVA422P10LE:
253  case AV_PIX_FMT_YUVA444P10LE:
254  case AV_PIX_FMT_YUV420P12LE:
255  case AV_PIX_FMT_YUV422P12LE:
256  case AV_PIX_FMT_YUV440P12LE:
257  case AV_PIX_FMT_YUV444P12LE:
258  case AV_PIX_FMT_YUV420P14LE:
259  case AV_PIX_FMT_YUV422P14LE:
260  case AV_PIX_FMT_YUV444P14LE:
261  case AV_PIX_FMT_YUV420P16LE:
262  case AV_PIX_FMT_YUV422P16LE:
263  case AV_PIX_FMT_YUV444P16LE:
264  case AV_PIX_FMT_YUVA420P16LE:
265  case AV_PIX_FMT_YUVA422P16LE:
266  case AV_PIX_FMT_YUVA444P16LE:
267  min[Y] = 16 * (1 << (desc->comp[0].depth - 8));
268  min[U] = 16 * (1 << (desc->comp[1].depth - 8));
269  min[V] = 16 * (1 << (desc->comp[2].depth - 8));
270  min[A] = 0;
271  max[Y] = 235 * (1 << (desc->comp[0].depth - 8));
272  max[U] = 240 * (1 << (desc->comp[1].depth - 8));
273  max[V] = 240 * (1 << (desc->comp[2].depth - 8));
274  max[A] = (1 << desc->comp[0].depth) - 1;
275  break;
276  case AV_PIX_FMT_RGB48LE:
277  case AV_PIX_FMT_RGBA64LE:
278  min[0] = min[1] = min[2] = min[3] = 0;
279  max[0] = max[1] = max[2] = max[3] = 65535;
280  break;
281  default:
282  min[0] = min[1] = min[2] = min[3] = 0;
283  max[0] = max[1] = max[2] = max[3] = 255 * (1 << (desc->comp[0].depth - 8));
284  }
285 
286  s->is_yuv = s->is_rgb = 0;
287  s->is_planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
288  if (ff_fmt_is_in(inlink->format, yuv_pix_fmts)) s->is_yuv = 1;
289  else if (ff_fmt_is_in(inlink->format, rgb_pix_fmts)) s->is_rgb = 1;
290 
291  if (s->is_rgb) {
292  ff_fill_rgba_map(rgba_map, inlink->format);
293  s->step = av_get_bits_per_pixel(desc) >> 3;
294  if (s->is_16bit) {
295  s->step = s->step >> 1;
296  }
297  }
298 
299  for (color = 0; color < desc->nb_components; color++) {
300  double res;
301  int comp = s->is_rgb ? rgba_map[color] : color;
302 
303  /* create the parsed expression */
304  av_expr_free(s->comp_expr[color]);
305  s->comp_expr[color] = NULL;
306  ret = av_expr_parse(&s->comp_expr[color], s->comp_expr_str[color],
307  var_names, funcs1_names, funcs1, NULL, NULL, 0, ctx);
308  if (ret < 0) {
309  av_log(ctx, AV_LOG_ERROR,
310  "Error when parsing the expression '%s' for the component %d and color %d.\n",
311  s->comp_expr_str[comp], comp, color);
312  return AVERROR(EINVAL);
313  }
314 
315  /* compute the lut */
316  s->var_values[VAR_MAXVAL] = max[color];
317  s->var_values[VAR_MINVAL] = min[color];
318 
319  for (val = 0; val < FF_ARRAY_ELEMS(s->lut[comp]); val++) {
320  s->var_values[VAR_VAL] = val;
321  s->var_values[VAR_CLIPVAL] = av_clip(val, min[color], max[color]);
322  s->var_values[VAR_NEGVAL] =
323  av_clip(min[color] + max[color] - s->var_values[VAR_VAL],
324  min[color], max[color]);
325 
326  res = av_expr_eval(s->comp_expr[color], s->var_values, s);
327  if (isnan(res)) {
328  av_log(ctx, AV_LOG_ERROR,
329  "Error when evaluating the expression '%s' for the value %d for the component %d.\n",
330  s->comp_expr_str[color], val, comp);
331  return AVERROR(EINVAL);
332  }
333  s->lut[comp][val] = av_clip((int)res, 0, max[A]);
334  av_log(ctx, AV_LOG_DEBUG, "val[%d][%d] = %d\n", comp, val, s->lut[comp][val]);
335  }
336  }
337 
338  return 0;
339 }
340 
341  struct thread_data {
342   AVFrame *in;
343   AVFrame *out;
344 
345   int w;
346   int h;
347 };
348 
349  #define LOAD_PACKED_COMMON\
350  LutContext *s = ctx->priv;\
351  const struct thread_data *td = arg;\
352 \
353  int i, j;\
354  const int w = td->w;\
355  const int h = td->h;\
356  AVFrame *in = td->in;\
357  AVFrame *out = td->out;\
358  const uint16_t (*tab)[256*256] = (const uint16_t (*)[256*256])s->lut;\
359  const int step = s->step;\
360 \
361  const int slice_start = (h * jobnr ) / nb_jobs;\
362  const int slice_end = (h * (jobnr+1)) / nb_jobs;\
363 
364 /* packed, 16-bit */
365  static int lut_packed_16bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
366 {
367  LOAD_PACKED_COMMON
368 
369  uint16_t *inrow, *outrow, *inrow0, *outrow0;
370  const int in_linesize = in->linesize[0] / 2;
371  const int out_linesize = out->linesize[0] / 2;
372  inrow0 = (uint16_t *)in ->data[0];
373  outrow0 = (uint16_t *)out->data[0];
374 
375  for (i = slice_start; i < slice_end; i++) {
376  inrow = inrow0 + i * in_linesize;
377  outrow = outrow0 + i * out_linesize;
378  for (j = 0; j < w; j++) {
379 
380  switch (step) {
381 #if HAVE_BIGENDIAN
382  case 4: outrow[3] = av_bswap16(tab[3][av_bswap16(inrow[3])]); // Fall-through
383  case 3: outrow[2] = av_bswap16(tab[2][av_bswap16(inrow[2])]); // Fall-through
384  case 2: outrow[1] = av_bswap16(tab[1][av_bswap16(inrow[1])]); // Fall-through
385  default: outrow[0] = av_bswap16(tab[0][av_bswap16(inrow[0])]);
386 #else
387  case 4: outrow[3] = tab[3][inrow[3]]; // Fall-through
388  case 3: outrow[2] = tab[2][inrow[2]]; // Fall-through
389  case 2: outrow[1] = tab[1][inrow[1]]; // Fall-through
390  default: outrow[0] = tab[0][inrow[0]];
391 #endif
392  }
393  outrow += step;
394  inrow += step;
395  }
396  }
397 
398  return 0;
399 }
400 
401 /* packed, 8-bit */
402  static int lut_packed_8bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
403 {
404  LOAD_PACKED_COMMON
405 
406  uint8_t *inrow, *outrow, *inrow0, *outrow0;
407  const int in_linesize = in->linesize[0];
408  const int out_linesize = out->linesize[0];
409  inrow0 = in ->data[0];
410  outrow0 = out->data[0];
411 
412  for (i = slice_start; i < slice_end; i++) {
413  inrow = inrow0 + i * in_linesize;
414  outrow = outrow0 + i * out_linesize;
415  for (j = 0; j < w; j++) {
416  switch (step) {
417  case 4: outrow[3] = tab[3][inrow[3]]; // Fall-through
418  case 3: outrow[2] = tab[2][inrow[2]]; // Fall-through
419  case 2: outrow[1] = tab[1][inrow[1]]; // Fall-through
420  default: outrow[0] = tab[0][inrow[0]];
421  }
422  outrow += step;
423  inrow += step;
424  }
425  }
426 
427  return 0;
428 }
429 
430  #define LOAD_PLANAR_COMMON\
431  LutContext *s = ctx->priv;\
432  const struct thread_data *td = arg;\
433  int i, j, plane;\
434  AVFrame *in = td->in;\
435  AVFrame *out = td->out;\
436 
437  #define PLANAR_COMMON\
438  int vsub = plane == 1 || plane == 2 ? s->vsub : 0;\
439  int hsub = plane == 1 || plane == 2 ? s->hsub : 0;\
440  int h = AV_CEIL_RSHIFT(td->h, vsub);\
441  int w = AV_CEIL_RSHIFT(td->w, hsub);\
442  const uint16_t *tab = s->lut[plane];\
443 \
444  const int slice_start = (h * jobnr ) / nb_jobs;\
445  const int slice_end = (h * (jobnr+1)) / nb_jobs;\
446 
447 /* planar >8 bit depth */
448  static int lut_planar_16bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
449 {
450  LOAD_PLANAR_COMMON
451 
452  uint16_t *inrow, *outrow;
453 
454  for (plane = 0; plane < 4 && in->data[plane] && in->linesize[plane]; plane++) {
455  PLANAR_COMMON
456 
457  const int in_linesize = in->linesize[plane] / 2;
458  const int out_linesize = out->linesize[plane] / 2;
459 
460  inrow = (uint16_t *)in ->data[plane] + slice_start * in_linesize;
461  outrow = (uint16_t *)out->data[plane] + slice_start * out_linesize;
462 
463  for (i = slice_start; i < slice_end; i++) {
464  for (j = 0; j < w; j++) {
465 #if HAVE_BIGENDIAN
466  outrow[j] = av_bswap16(tab[av_bswap16(inrow[j])]);
467 #else
468  outrow[j] = tab[inrow[j]];
469 #endif
470  }
471  inrow += in_linesize;
472  outrow += out_linesize;
473  }
474  }
475 
476  return 0;
477 }
478 
479 /* planar 8bit depth */
480  static int lut_planar_8bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
481 {
482  LOAD_PLANAR_COMMON
483 
484  uint8_t *inrow, *outrow;
485 
486  for (plane = 0; plane < 4 && in->data[plane] && in->linesize[plane]; plane++) {
487  PLANAR_COMMON
488 
489  const int in_linesize = in->linesize[plane];
490  const int out_linesize = out->linesize[plane];
491 
492  inrow = in ->data[plane] + slice_start * in_linesize;
493  outrow = out->data[plane] + slice_start * out_linesize;
494 
495  for (i = slice_start; i < slice_end; i++) {
496  for (j = 0; j < w; j++)
497  outrow[j] = tab[inrow[j]];
498  inrow += in_linesize;
499  outrow += out_linesize;
500  }
501  }
502 
503  return 0;
504 }
505 
506  #define PACKED_THREAD_DATA\
507  struct thread_data td = {\
508  .in = in,\
509  .out = out,\
510  .w = inlink->w,\
511  .h = in->height,\
512  };\
513 
514  #define PLANAR_THREAD_DATA\
515  struct thread_data td = {\
516  .in = in,\
517  .out = out,\
518  .w = inlink->w,\
519  .h = inlink->h,\
520  };\
521 
522  static int filter_frame(AVFilterLink *inlink, AVFrame *in)
523 {
524  AVFilterContext *ctx = inlink->dst;
525  LutContext *s = ctx->priv;
526  AVFilterLink *outlink = ctx->outputs[0];
527  AVFrame *out;
528  int direct = 0;
529 
530  if (av_frame_is_writable(in)) {
531  direct = 1;
532  out = in;
533  } else {
534  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
535  if (!out) {
536  av_frame_free(&in);
537  return AVERROR(ENOMEM);
538  }
539  av_frame_copy_props(out, in);
540  }
541 
542  av_frame_side_data_remove_by_props(&out->side_data, &out->nb_side_data,
543  AV_SIDE_DATA_PROP_COLOR_DEPENDENT);
544 
545  if (s->is_rgb && s->is_16bit && !s->is_planar) {
546  /* packed, 16-bit */
547  PACKED_THREAD_DATA
548  ff_filter_execute(ctx, lut_packed_16bits, &td, NULL,
549  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
550  } else if (s->is_rgb && !s->is_planar) {
551  /* packed 8 bits */
552  PACKED_THREAD_DATA
553  ff_filter_execute(ctx, lut_packed_8bits, &td, NULL,
554  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
555  } else if (s->is_16bit) {
556  /* planar >8 bit depth */
557  PLANAR_THREAD_DATA
558  ff_filter_execute(ctx, lut_planar_16bits, &td, NULL,
559  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
560  } else {
561  /* planar 8bit depth */
562  PLANAR_THREAD_DATA
563  ff_filter_execute(ctx, lut_planar_8bits, &td, NULL,
564  FFMIN(in->height, ff_filter_get_nb_threads(ctx)));
565  }
566 
567  if (!direct)
568  av_frame_free(&in);
569 
570  return ff_filter_frame(outlink, out);
571 }
572 
573  static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
574  char *res, int res_len, int flags)
575 {
576  int ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
577 
578  if (ret < 0)
579  return ret;
580 
581  return config_props(ctx->inputs[0]);
582 }
583 
584  static const AVFilterPad inputs[] = {
585  { .name = "default",
586  .type = AVMEDIA_TYPE_VIDEO,
587  .filter_frame = filter_frame,
588  .config_props = config_props,
589  },
590 };
591 
592  #define DEFINE_LUT_FILTER(name_, description_, priv_class_) \
593  const FFFilter ff_vf_##name_ = { \
594  .p.name = #name_, \
595  .p.description = NULL_IF_CONFIG_SMALL(description_), \
596  .p.priv_class = &priv_class_ ## _class, \
597  .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | \
598  AVFILTER_FLAG_SLICE_THREADS, \
599  .priv_size = sizeof(LutContext), \
600  .init = name_##_init, \
601  .uninit = uninit, \
602  FILTER_INPUTS(inputs), \
603  FILTER_OUTPUTS(ff_video_default_filterpad), \
604  FILTER_QUERY_FUNC2(query_formats), \
605  .process_command = process_command, \
606  }
607 
608 AVFILTER_DEFINE_CLASS_EXT(lut, "lut/lutyuv/lutrgb", options);
609 
610 #if CONFIG_LUT_FILTER
611 
612 #define lut_init NULL
613 DEFINE_LUT_FILTER(lut, "Compute and apply a lookup table to the RGB/YUV input video.",
614  lut);
615 #undef lut_init
616 #endif
617 
618 #if CONFIG_LUTYUV_FILTER
619 
620 static av_cold int lutyuv_init(AVFilterContext *ctx)
621 {
622  LutContext *s = ctx->priv;
623 
624  s->is_yuv = 1;
625 
626  return 0;
627 }
628 
629 DEFINE_LUT_FILTER(lutyuv, "Compute and apply a lookup table to the YUV input video.",
630  lut);
631 #endif
632 
633 #if CONFIG_LUTRGB_FILTER
634 
635 static av_cold int lutrgb_init(AVFilterContext *ctx)
636 {
637  LutContext *s = ctx->priv;
638 
639  s->is_rgb = 1;
640 
641  return 0;
642 }
643 
644 DEFINE_LUT_FILTER(lutrgb, "Compute and apply a lookup table to the RGB input video.",
645  lut);
646 #endif
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(lut, "lut/lutyuv/lutrgb", options)
flags
const SwsFlags flags[]
Definition: swscale.c:61
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:117
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
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:208
av_clip
#define av_clip
Definition: common.h:100
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:46
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:189
GRAY_FORMATS
#define GRAY_FORMATS
Definition: vf_lut.c:140
PLANAR_COMMON
#define PLANAR_COMMON
Definition: vf_lut.c:437
out
FILE * out
Definition: movenc.c:55
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_lut.c:522
color
Definition: vf_paletteuse.c:513
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:79
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1067
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3447
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
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:64
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
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:429
B
#define B
Definition: vf_lut.c:82
data
const char data[16]
Definition: mxf.c:149
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:3399
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:345
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
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
Definition: mpeg12dec.c:1688
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:506
val
static double val(void *priv, double ch)
Definition: aeval.c:77
LOAD_PACKED_COMMON
#define LOAD_PACKED_COMMON
Definition: vf_lut.c:349
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:208
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
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:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:106
thread_data
Definition: vf_lut.c:341
funcs1
static double(*const funcs1[])(void *, double)
Definition: vf_lut.c:201
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
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:298
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
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
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:422
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:514
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:76
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:599
isnan
#define isnan(x)
Definition: libm.h:342
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
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: vf_lut.c:148
options
Definition: swscale.c:43
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
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: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:402
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:121
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:346
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:573
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:480
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:424
LutContext::hsub
int hsub
Definition: vf_lut.c:69
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:97
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:535
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:430
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:905
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:365
attributes.h
rgb_pix_fmts
static enum AVPixelFormat rgb_pix_fmts[]
Definition: vf_lut.c:145
av_frame_side_data_remove_by_props
void av_frame_side_data_remove_by_props(AVFrameSideData ***sd, int *nb_sd, int props)
Remove and free all side data instances that match any of the given side data properties.
Definition: side_data.c:117
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
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:845
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
AV_SIDE_DATA_PROP_COLOR_DEPENDENT
@ AV_SIDE_DATA_PROP_COLOR_DEPENDENT
Side data depends on the video color space.
Definition: frame.h:316
slice_start
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
Definition: dec.c:845
inputs
static const AVFilterPad inputs[]
Definition: vf_lut.c:584
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:499
ff_set_common_formats_from_list2
int ff_set_common_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *fmts)
Definition: formats.c:1085
ff_filter_execute
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:1693
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
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
AVFilterContext
An instance of a filter.
Definition: avfilter.h:274
V
#define V
Definition: vf_lut.c:79
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
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:35
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:80
LutContext::is_planar
int is_planar
Definition: vf_lut.c:72
thread_data::in
AVFrame * in
Definition: vf_lut.c:342
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
thread_data::out
AVFrame * out
Definition: vf_lut.c:343
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:215
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
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
drawutils.h
av_bswap16
#define av_bswap16
Definition: bswap.h:28
lut_planar_16bits
static int lut_planar_16bits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_lut.c:448
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:163
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:176
DEFINE_LUT_FILTER
#define DEFINE_LUT_FILTER(name_, description_, priv_class_)
Definition: vf_lut.c:592
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 Oct 17 2025 19:23:07 for FFmpeg by   doxygen 1.8.17

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