FFmpeg
vf_geq.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2006 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (C) 2012 Clément Bœsch <u pkh me>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Generic equation change filter
25  * Originally written by Michael Niedermayer for the MPlayer project, and
26  * ported by Clément Bœsch for FFmpeg.
27  */
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/eval.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "internal.h"
35 
36 #define MAX_NB_THREADS 32
37 #define NB_PLANES 4
38 
43 };
44 
45 static const char *const var_names[] = { "X", "Y", "W", "H", "N", "SW", "SH", "T", NULL };
47 
48 typedef struct GEQContext {
49  const AVClass *class;
50  AVExpr *e[NB_PLANES][MAX_NB_THREADS]; ///< expressions for each plane and thread
51  char *expr_str[4+3]; ///< expression strings for each plane
52  AVFrame *picref; ///< current input buffer
53  uint8_t *dst; ///< reference pointer to the 8bits output
54  uint16_t *dst16; ///< reference pointer to the 16bits output
55  float *dst32; ///< reference pointer to the 32bits output
56  double values[VAR_VARS_NB]; ///< expression values
57  int hsub, vsub; ///< chroma subsampling
58  int planes; ///< number of planes
60  int is_rgb;
61  int bps;
62 
65 } GEQContext;
66 
67 enum { Y = 0, U, V, A, G, B, R };
68 
69 #define OFFSET(x) offsetof(GEQContext, x)
70 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
71 
72 static const AVOption geq_options[] = {
73  { "lum_expr", "set luminance expression", OFFSET(expr_str[Y]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
74  { "lum", "set luminance expression", OFFSET(expr_str[Y]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
75  { "cb_expr", "set chroma blue expression", OFFSET(expr_str[U]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
76  { "cb", "set chroma blue expression", OFFSET(expr_str[U]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
77  { "cr_expr", "set chroma red expression", OFFSET(expr_str[V]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
78  { "cr", "set chroma red expression", OFFSET(expr_str[V]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
79  { "alpha_expr", "set alpha expression", OFFSET(expr_str[A]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
80  { "a", "set alpha expression", OFFSET(expr_str[A]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
81  { "red_expr", "set red expression", OFFSET(expr_str[R]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
82  { "r", "set red expression", OFFSET(expr_str[R]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
83  { "green_expr", "set green expression", OFFSET(expr_str[G]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
84  { "g", "set green expression", OFFSET(expr_str[G]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
85  { "blue_expr", "set blue expression", OFFSET(expr_str[B]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
86  { "b", "set blue expression", OFFSET(expr_str[B]), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
87  { "interpolation","set interpolation method", OFFSET(interpolation), AV_OPT_TYPE_INT, {.i64=INTERP_BILINEAR}, 0, NB_INTERP-1, FLAGS, "interp" },
88  { "i", "set interpolation method", OFFSET(interpolation), AV_OPT_TYPE_INT, {.i64=INTERP_BILINEAR}, 0, NB_INTERP-1, FLAGS, "interp" },
89  { "nearest", "nearest interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERP_NEAREST}, 0, 0, FLAGS, "interp" },
90  { "n", "nearest interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERP_NEAREST}, 0, 0, FLAGS, "interp" },
91  { "bilinear", "bilinear interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERP_BILINEAR}, 0, 0, FLAGS, "interp" },
92  { "b", "bilinear interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERP_BILINEAR}, 0, 0, FLAGS, "interp" },
93  {NULL},
94 };
95 
97 
98 static inline double getpix(void *priv, double x, double y, int plane)
99 {
100  int xi, yi;
101  GEQContext *geq = priv;
102  AVFrame *picref = geq->picref;
103  const uint8_t *src = picref->data[plane];
104  int linesize = picref->linesize[plane];
105  const int w = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(picref->width, geq->hsub) : picref->width;
106  const int h = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(picref->height, geq->vsub) : picref->height;
107 
108  if (!src)
109  return 0;
110 
111  if (geq->interpolation == INTERP_BILINEAR) {
112  xi = x = av_clipd(x, 0, w - 2);
113  yi = y = av_clipd(y, 0, h - 2);
114 
115  x -= xi;
116  y -= yi;
117 
118  if (geq->bps > 8 && geq->bps <= 16) {
119  const uint16_t *src16 = (const uint16_t*)src;
120  linesize /= 2;
121 
122  return (1-y)*((1-x)*src16[xi + yi * linesize] + x*src16[xi + 1 + yi * linesize])
123  + y *((1-x)*src16[xi + (yi+1) * linesize] + x*src16[xi + 1 + (yi+1) * linesize]);
124  } else if (geq->bps == 32) {
125  const float *src32 = (const float*)src;
126  linesize /= 4;
127 
128  return (1-y)*((1-x)*src32[xi + yi * linesize] + x*src32[xi + 1 + yi * linesize])
129  + y *((1-x)*src32[xi + (yi+1) * linesize] + x*src32[xi + 1 + (yi+1) * linesize]);
130  } else if (geq->bps == 8) {
131  return (1-y)*((1-x)*src[xi + yi * linesize] + x*src[xi + 1 + yi * linesize])
132  + y *((1-x)*src[xi + (yi+1) * linesize] + x*src[xi + 1 + (yi+1) * linesize]);
133  }
134  } else {
135  xi = av_clipd(x, 0, w - 1);
136  yi = av_clipd(y, 0, h - 1);
137 
138  if (geq->bps > 8 && geq->bps <= 16) {
139  const uint16_t *src16 = (const uint16_t*)src;
140  linesize /= 2;
141 
142  return src16[xi + yi * linesize];
143  } else if (geq->bps == 32) {
144  const float *src32 = (const float*)src;
145  linesize /= 4;
146 
147  return src32[xi + yi * linesize];
148  } else if (geq->bps == 8) {
149  return src[xi + yi * linesize];
150  }
151  }
152 
153  return 0;
154 }
155 
156 static int calculate_sums(GEQContext *geq, int plane, int w, int h)
157 {
158  int xi, yi;
159  AVFrame *picref = geq->picref;
160  const uint8_t *src = picref->data[plane];
161  int linesize = picref->linesize[plane];
162 
163  if (!geq->pixel_sums[plane])
164  geq->pixel_sums[plane] = av_malloc_array(w, h * sizeof (*geq->pixel_sums[plane]));
165  if (!geq->pixel_sums[plane])
166  return AVERROR(ENOMEM);
167  if (geq->bps == 32)
168  linesize /= 4;
169  else if (geq->bps > 8 && geq->bps <= 16)
170  linesize /= 2;
171  for (yi = 0; yi < h; yi ++) {
172  if (geq->bps > 8 && geq->bps <= 16) {
173  const uint16_t *src16 = (const uint16_t*)src;
174  double linesum = 0;
175 
176  for (xi = 0; xi < w; xi ++) {
177  linesum += src16[xi + yi * linesize];
178  geq->pixel_sums[plane][xi + yi * w] = linesum;
179  }
180  } else if (geq->bps == 8) {
181  double linesum = 0;
182 
183  for (xi = 0; xi < w; xi ++) {
184  linesum += src[xi + yi * linesize];
185  geq->pixel_sums[plane][xi + yi * w] = linesum;
186  }
187  } else if (geq->bps == 32) {
188  const float *src32 = (const float*)src;
189  double linesum = 0;
190 
191  for (xi = 0; xi < w; xi ++) {
192  linesum += src32[xi + yi * linesize];
193  geq->pixel_sums[plane][xi + yi * w] = linesum;
194  }
195  }
196  if (yi)
197  for (xi = 0; xi < w; xi ++) {
198  geq->pixel_sums[plane][xi + yi * w] += geq->pixel_sums[plane][xi + yi * w - w];
199  }
200  }
201  return 0;
202 }
203 
204 static inline double getpix_integrate_internal(GEQContext *geq, int x, int y, int plane, int w, int h)
205 {
206  if (x > w - 1) {
207  double boundary = getpix_integrate_internal(geq, w - 1, y, plane, w, h);
208  return 2*boundary - getpix_integrate_internal(geq, 2*(w - 1) - x, y, plane, w, h);
209  } else if (y > h - 1) {
210  double boundary = getpix_integrate_internal(geq, x, h - 1, plane, w, h);
211  return 2*boundary - getpix_integrate_internal(geq, x, 2*(h - 1) - y, plane, w, h);
212  } else if (x < 0) {
213  if (x == -1) return 0;
214  return - getpix_integrate_internal(geq, -x-2, y, plane, w, h);
215  } else if (y < 0) {
216  if (y == -1) return 0;
217  return - getpix_integrate_internal(geq, x, -y-2, plane, w, h);
218  }
219 
220  return geq->pixel_sums[plane][x + y * w];
221 }
222 
223 static inline double getpix_integrate(void *priv, double x, double y, int plane) {
224  GEQContext *geq = priv;
225  AVFrame *picref = geq->picref;
226  const uint8_t *src = picref->data[plane];
227  const int w = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(picref->width, geq->hsub) : picref->width;
228  const int h = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(picref->height, geq->vsub) : picref->height;
229 
230  if (!src)
231  return 0;
232 
233  return getpix_integrate_internal(geq, lrint(av_clipd(x, -w, 2*w)), lrint(av_clipd(y, -h, 2*h)), plane, w, h);
234 }
235 
236 //TODO: cubic interpolate
237 //TODO: keep the last few frames
238 static double lum(void *priv, double x, double y) { return getpix(priv, x, y, 0); }
239 static double cb(void *priv, double x, double y) { return getpix(priv, x, y, 1); }
240 static double cr(void *priv, double x, double y) { return getpix(priv, x, y, 2); }
241 static double alpha(void *priv, double x, double y) { return getpix(priv, x, y, 3); }
242 
243 static double lumsum(void *priv, double x, double y) { return getpix_integrate(priv, x, y, 0); }
244 static double cbsum(void *priv, double x, double y) { return getpix_integrate(priv, x, y, 1); }
245 static double crsub(void *priv, double x, double y) { return getpix_integrate(priv, x, y, 2); }
246 static double alphasum(void *priv, double x, double y) { return getpix_integrate(priv, x, y, 3); }
247 
249 {
250  GEQContext *geq = ctx->priv;
251  int plane, ret = 0;
252 
253  if (!geq->expr_str[Y] && !geq->expr_str[G] && !geq->expr_str[B] && !geq->expr_str[R]) {
254  av_log(ctx, AV_LOG_ERROR, "A luminance or RGB expression is mandatory\n");
255  ret = AVERROR(EINVAL);
256  goto end;
257  }
258  geq->is_rgb = !geq->expr_str[Y];
259 
260  if ((geq->expr_str[Y] || geq->expr_str[U] || geq->expr_str[V]) && (geq->expr_str[G] || geq->expr_str[B] || geq->expr_str[R])) {
261  av_log(ctx, AV_LOG_ERROR, "Either YCbCr or RGB but not both must be specified\n");
262  ret = AVERROR(EINVAL);
263  goto end;
264  }
265 
266  if (!geq->expr_str[U] && !geq->expr_str[V]) {
267  /* No chroma at all: fallback on luma */
268  geq->expr_str[U] = av_strdup(geq->expr_str[Y]);
269  geq->expr_str[V] = av_strdup(geq->expr_str[Y]);
270  } else {
271  /* One chroma unspecified, fallback on the other */
272  if (!geq->expr_str[U]) geq->expr_str[U] = av_strdup(geq->expr_str[V]);
273  if (!geq->expr_str[V]) geq->expr_str[V] = av_strdup(geq->expr_str[U]);
274  }
275 
276  if (!geq->expr_str[A] && geq->bps != 32) {
277  geq->expr_str[A] = av_asprintf("%d", (1<<geq->bps) - 1);
278  } else if (!geq->expr_str[A]) {
279  geq->expr_str[A] = av_asprintf("%f", 1.f);
280  }
281  if (!geq->expr_str[G])
282  geq->expr_str[G] = av_strdup("g(X,Y)");
283  if (!geq->expr_str[B])
284  geq->expr_str[B] = av_strdup("b(X,Y)");
285  if (!geq->expr_str[R])
286  geq->expr_str[R] = av_strdup("r(X,Y)");
287 
288  if (geq->is_rgb ?
289  (!geq->expr_str[G] || !geq->expr_str[B] || !geq->expr_str[R])
290  :
291  (!geq->expr_str[U] || !geq->expr_str[V] || !geq->expr_str[A])) {
292  ret = AVERROR(ENOMEM);
293  goto end;
294  }
295 
296  for (plane = 0; plane < NB_PLANES; plane++) {
297  static double (*const p[])(void *, double, double) = {
298  lum , cb , cr , alpha ,
300  };
301  static const char *const func2_yuv_names[] = {
302  "lum" , "cb" , "cr" , "alpha" , "p",
303  "lumsum", "cbsum", "crsum", "alphasum", "psum",
304  NULL };
305  static const char *const func2_rgb_names[] = {
306  "g" , "b" , "r" , "alpha" , "p",
307  "gsum", "bsum", "rsum", "alphasum", "psum",
308  NULL };
309  const char *const *func2_names = geq->is_rgb ? func2_rgb_names : func2_yuv_names;
310  double (*const func2[])(void *, double, double) = {
311  lum , cb , cr , alpha , p[plane],
312  lumsum, cbsum, crsub, alphasum, p[plane + 4],
313  NULL };
314  int counter[10] = {0};
315 
316  for (int i = 0; i < MAX_NB_THREADS; i++) {
317  ret = av_expr_parse(&geq->e[plane][i], geq->expr_str[plane < 3 && geq->is_rgb ? plane+4 : plane], var_names,
318  NULL, NULL, func2_names, func2, 0, ctx);
319  if (ret < 0)
320  goto end;
321  }
322 
323  av_expr_count_func(geq->e[plane][0], counter, FF_ARRAY_ELEMS(counter), 2);
324  geq->needs_sum[plane] = counter[5] + counter[6] + counter[7] + counter[8] + counter[9];
325  }
326 
327 end:
328  return ret;
329 }
330 
332 {
333  GEQContext *geq = ctx->priv;
334  static const enum AVPixelFormat yuv_pix_fmts[] = {
353  };
354  static const enum AVPixelFormat rgb_pix_fmts[] = {
363  };
364  const enum AVPixelFormat *pix_fmts = geq->is_rgb ? rgb_pix_fmts : yuv_pix_fmts;
365 
367 }
368 
370 {
371  GEQContext *geq = inlink->dst->priv;
373 
374  av_assert0(desc);
375 
376  geq->hsub = desc->log2_chroma_w;
377  geq->vsub = desc->log2_chroma_h;
378  geq->bps = desc->comp[0].depth;
379  geq->planes = desc->nb_components;
380  return 0;
381 }
382 
383 typedef struct ThreadData {
384  int height;
385  int width;
386  int plane;
387  int linesize;
388 } ThreadData;
389 
390 static int slice_geq_filter(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
391 {
392  GEQContext *geq = ctx->priv;
393  ThreadData *td = arg;
394  const int height = td->height;
395  const int width = td->width;
396  const int plane = td->plane;
397  const int linesize = td->linesize;
398  const int slice_start = (height * jobnr) / nb_jobs;
399  const int slice_end = (height * (jobnr+1)) / nb_jobs;
400  int x, y;
401 
402  double values[VAR_VARS_NB];
403  values[VAR_W] = geq->values[VAR_W];
404  values[VAR_H] = geq->values[VAR_H];
405  values[VAR_N] = geq->values[VAR_N];
406  values[VAR_SW] = geq->values[VAR_SW];
407  values[VAR_SH] = geq->values[VAR_SH];
408  values[VAR_T] = geq->values[VAR_T];
409 
410  if (geq->bps == 8) {
411  uint8_t *ptr = geq->dst + linesize * slice_start;
412  for (y = slice_start; y < slice_end; y++) {
413  values[VAR_Y] = y;
414 
415  for (x = 0; x < width; x++) {
416  values[VAR_X] = x;
417  ptr[x] = av_expr_eval(geq->e[plane][jobnr], values, geq);
418  }
419  ptr += linesize;
420  }
421  } else if (geq->bps <= 16) {
422  uint16_t *ptr16 = geq->dst16 + (linesize/2) * slice_start;
423  for (y = slice_start; y < slice_end; y++) {
424  values[VAR_Y] = y;
425  for (x = 0; x < width; x++) {
426  values[VAR_X] = x;
427  ptr16[x] = av_expr_eval(geq->e[plane][jobnr], values, geq);
428  }
429  ptr16 += linesize/2;
430  }
431  } else {
432  float *ptr32 = geq->dst32 + (linesize/4) * slice_start;
433  for (y = slice_start; y < slice_end; y++) {
434  values[VAR_Y] = y;
435  for (x = 0; x < width; x++) {
436  values[VAR_X] = x;
437  ptr32[x] = av_expr_eval(geq->e[plane][jobnr], values, geq);
438  }
439  ptr32 += linesize/4;
440  }
441  }
442 
443  return 0;
444 }
445 
447 {
448  int plane;
449  AVFilterContext *ctx = inlink->dst;
450  const int nb_threads = FFMIN(MAX_NB_THREADS, ff_filter_get_nb_threads(ctx));
451  GEQContext *geq = ctx->priv;
452  AVFilterLink *outlink = inlink->dst->outputs[0];
453  AVFrame *out;
454 
455  geq->values[VAR_N] = inlink->frame_count_out,
456  geq->values[VAR_T] = in->pts == AV_NOPTS_VALUE ? NAN : in->pts * av_q2d(inlink->time_base),
457 
458  geq->picref = in;
459  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
460  if (!out) {
461  av_frame_free(&in);
462  return AVERROR(ENOMEM);
463  }
465 
466  for (plane = 0; plane < geq->planes && out->data[plane]; plane++) {
467  const int width = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(inlink->w, geq->hsub) : inlink->w;
468  const int height = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(inlink->h, geq->vsub) : inlink->h;
469  const int linesize = out->linesize[plane];
470  ThreadData td;
471 
472  geq->dst = out->data[plane];
473  geq->dst16 = (uint16_t*)out->data[plane];
474  geq->dst32 = (float*)out->data[plane];
475 
476  geq->values[VAR_W] = width;
477  geq->values[VAR_H] = height;
478  geq->values[VAR_SW] = width / (double)inlink->w;
479  geq->values[VAR_SH] = height / (double)inlink->h;
480 
481  td.width = width;
482  td.height = height;
483  td.plane = plane;
484  td.linesize = linesize;
485 
486  if (geq->needs_sum[plane])
487  calculate_sums(geq, plane, width, height);
488 
490  NULL, FFMIN(height, nb_threads));
491  }
492 
493  av_frame_free(&geq->picref);
494  return ff_filter_frame(outlink, out);
495 }
496 
498 {
499  int i;
500  GEQContext *geq = ctx->priv;
501 
502  for (i = 0; i < NB_PLANES; i++)
503  for (int j = 0; j < MAX_NB_THREADS; j++)
504  av_expr_free(geq->e[i][j]);
505  for (i = 0; i < NB_PLANES; i++)
506  av_freep(&geq->pixel_sums);
507 }
508 
509 static const AVFilterPad geq_inputs[] = {
510  {
511  .name = "default",
512  .type = AVMEDIA_TYPE_VIDEO,
513  .config_props = geq_config_props,
514  .filter_frame = geq_filter_frame,
515  },
516 };
517 
518 static const AVFilterPad geq_outputs[] = {
519  {
520  .name = "default",
521  .type = AVMEDIA_TYPE_VIDEO,
522  },
523 };
524 
526  .name = "geq",
527  .description = NULL_IF_CONFIG_SMALL("Apply generic equation to each pixel."),
528  .priv_size = sizeof(GEQContext),
529  .init = geq_init,
530  .uninit = geq_uninit,
534  .priv_class = &geq_class,
536 };
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_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:449
B
@ B
Definition: vf_geq.c:67
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:428
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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
getpix
static double getpix(void *priv, double x, double y, int plane)
Definition: vf_geq.c:98
var_names
static const char *const var_names[]
Definition: vf_geq.c:45
out
FILE * out
Definition: movenc.c:54
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:239
VAR_H
@ VAR_H
Definition: vf_geq.c:46
geq_query_formats
static int geq_query_formats(AVFilterContext *ctx)
Definition: vf_geq.c:331
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:999
geq_uninit
static av_cold void geq_uninit(AVFilterContext *ctx)
Definition: vf_geq.c:497
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
geq_outputs
static const AVFilterPad geq_outputs[]
Definition: vf_geq.c:518
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
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:116
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
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:441
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:432
VAR_SW
@ VAR_SW
Definition: vf_geq.c:46
AVFrame::width
int width
Definition: frame.h:397
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:448
w
uint8_t w
Definition: llviddspenc.c:38
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:443
AVOption
AVOption.
Definition: opt.h:251
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:167
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:406
av_expr_count_func
int av_expr_count_func(AVExpr *e, unsigned *counter, int size, int arg)
Track the presence of user provided functions and their number of occurrences in a parsed expression.
Definition: eval.c:761
NB_INTERP
@ NB_INTERP
Definition: vf_geq.c:42
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
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
GEQContext::planes
int planes
number of planes
Definition: vf_geq.c:58
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:444
lumsum
static double lumsum(void *priv, double x, double y)
Definition: vf_geq.c:243
crsub
static double crsub(void *priv, double x, double y)
Definition: vf_geq.c:245
func2_names
static const char *const func2_names[]
Definition: af_afftfilt.c:98
ThreadData::width
int width
Definition: vf_avgblur.c:65
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:386
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
GEQContext::pixel_sums
double * pixel_sums[NB_PLANES]
Definition: vf_geq.c:63
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
init
static int init
Definition: av_tx.c:47
geq_config_props
static int geq_config_props(AVFilterLink *inlink)
Definition: vf_geq.c:369
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:440
GEQContext::interpolation
int interpolation
Definition: vf_geq.c:59
VAR_T
@ VAR_T
Definition: vf_geq.c:46
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:424
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:422
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:450
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:404
InterpolationMethods
InterpolationMethods
Definition: vf_geq.c:39
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:390
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:409
VAR_SH
@ VAR_SH
Definition: vf_geq.c:46
avassert.h
lrint
#define lrint
Definition: tablegen.h:53
func2
static double(*const func2[])(void *, double, double)
Definition: af_afftfilt.c:99
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
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:418
MAX_NB_THREADS
#define MAX_NB_THREADS
Definition: vf_geq.c:36
OFFSET
#define OFFSET(x)
Definition: vf_geq.c:69
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:426
ThreadData::plane
int plane
Definition: vf_blend.c:58
width
#define width
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:427
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
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:419
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
ThreadData::height
int height
Definition: vf_avgblur.c:64
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2013
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
NB_PLANES
#define NB_PLANES
Definition: vf_geq.c:37
GEQContext::vsub
int vsub
chroma subsampling
Definition: vf_geq.c:57
ThreadData::linesize
int linesize
Definition: vf_avgblur.c:68
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:403
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:417
ctx
AVFormatContext * ctx
Definition: movenc.c:48
xi
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:404
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:766
geq_options
static const AVOption geq_options[]
Definition: vf_geq.c:72
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:389
AVExpr
Definition: eval.c:157
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
R
@ R
Definition: vf_geq.c:67
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:438
NAN
#define NAN
Definition: mathematics.h:64
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:190
alpha
static double alpha(void *priv, double x, double y)
Definition: vf_geq.c:241
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:387
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:425
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
INTERP_NEAREST
@ INTERP_NEAREST
Definition: vf_geq.c:40
getpix_integrate
static double getpix_integrate(void *priv, double x, double y, int plane)
Definition: vf_geq.c:223
VAR_W
@ VAR_W
Definition: vf_geq.c:46
GEQContext::picref
AVFrame * picref
current input buffer
Definition: vf_geq.c:52
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:408
calculate_sums
static int calculate_sums(GEQContext *geq, int plane, int w, int h)
Definition: vf_geq.c:156
double
double
Definition: af_crystalizer.c:132
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:407
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:421
INTERP_BILINEAR
@ INTERP_BILINEAR
Definition: vf_geq.c:41
cbsum
static double cbsum(void *priv, double x, double y)
Definition: vf_geq.c:244
GEQContext::bps
int bps
Definition: vf_geq.c:61
GEQContext::e
AVExpr * e[NB_PLANES][MAX_NB_THREADS]
expressions for each plane and thread
Definition: vf_geq.c:50
eval.h
f
f
Definition: af_crystalizer.c:122
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
Y
@ Y
Definition: vf_geq.c:67
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:435
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:411
VAR_N
@ VAR_N
Definition: vf_geq.c:46
GEQContext::values
double values[VAR_VARS_NB]
expression values
Definition: vf_geq.c:56
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
VAR_VARS_NB
@ VAR_VARS_NB
Definition: vf_geq.c:46
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:413
geq_init
static av_cold int geq_init(AVFilterContext *ctx)
Definition: vf_geq.c:248
height
#define height
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
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:445
FLAGS
#define FLAGS
Definition: vf_geq.c:70
V
@ V
Definition: vf_geq.c:67
interpolation
static int interpolation(DeclickChannel *c, const double *src, int ar_order, double *acoefficients, int *index, int nb_errors, double *auxiliary, double *interpolated)
Definition: af_adeclick.c:336
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:152
VAR_X
@ VAR_X
Definition: vf_geq.c:46
GEQContext
Definition: vf_geq.c:48
GEQContext::is_rgb
int is_rgb
Definition: vf_geq.c:60
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
lum
static double lum(void *priv, double x, double y)
Definition: vf_geq.c:238
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:423
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
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
ThreadData
Used for passing data between threads.
Definition: dsddec.c:68
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
GEQContext::expr_str
char * expr_str[4+3]
expression strings for each plane
Definition: vf_geq.c:51
GEQContext::dst
uint8_t * dst
reference pointer to the 8bits output
Definition: vf_geq.c:53
GEQContext::dst16
uint16_t * dst16
reference pointer to the 16bits output
Definition: vf_geq.c:54
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:405
AVFilter
Filter definition.
Definition: avfilter.h:171
ret
ret
Definition: filter_design.txt:187
GEQContext::needs_sum
int needs_sum[NB_PLANES]
Definition: vf_geq.c:64
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:442
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:410
GEQContext::hsub
int hsub
Definition: vf_geq.c:57
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:415
AVFrame::height
int height
Definition: frame.h:397
U
@ U
Definition: vf_geq.c:67
geq_filter_frame
static int geq_filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_geq.c:446
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:436
values
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
Definition: filter_design.txt:263
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
AVFilterContext
An instance of a filter.
Definition: avfilter.h:408
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(geq)
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:127
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
desc
const char * desc
Definition: libsvtav1.c:83
alphasum
static double alphasum(void *priv, double x, double y)
Definition: vf_geq.c:246
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
yuv_pix_fmts
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:262
A
@ A
Definition: vf_geq.c:67
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:240
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
G
@ G
Definition: vf_geq.c:67
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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
VAR_Y
@ VAR_Y
Definition: vf_geq.c:46
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
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
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:285
h
h
Definition: vp9dsp_template.c:2038
GEQContext::dst32
float * dst32
reference pointer to the 32bits output
Definition: vf_geq.c:55
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:416
rgb_pix_fmts
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:260
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:388
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
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
slice_geq_filter
static int slice_geq_filter(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_geq.c:390
ff_vf_geq
const AVFilter ff_vf_geq
Definition: vf_geq.c:525
geq_inputs
static const AVFilterPad geq_inputs[]
Definition: vf_geq.c:509
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
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:414
getpix_integrate_internal
static double getpix_integrate_internal(GEQContext *geq, int x, int y, int plane, int w, int h)
Definition: vf_geq.c:204
av_clipd
av_clipd
Definition: af_crystalizer.c:132