FFmpeg
vf_estdif.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2021 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/common.h"
22 #include "libavutil/imgutils.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/pixdesc.h"
25 #include "avfilter.h"
26 #include "internal.h"
27 #include "video.h"
28 
29 typedef struct ESTDIFContext {
30  const AVClass *class;
31 
32  int mode; ///< 0 is frame, 1 is field
33  int parity; ///< frame field parity
34  int deint; ///< which frames to deinterlace
35  int rslope; ///< best edge slope search radius
36  int redge; ///< best edge match search radius
37  int ecost; ///< edge cost for edge matching
38  int mcost; ///< middle cost for edge matching
39  int dcost; ///< distance cost for edge matching
40  int interp; ///< type of interpolation
41  int linesize[4]; ///< bytes of pixel data per line for each plane
42  int planewidth[4]; ///< width of each plane
43  int planeheight[4]; ///< height of each plane
44  int field; ///< which field are we on, 0 or 1
45  int eof;
46  int depth;
47  int max;
48  int nb_planes;
51 
52  void (*interpolate)(struct ESTDIFContext *s, uint8_t *dst,
53  const uint8_t *prev_line, const uint8_t *next_line,
54  const uint8_t *prev2_line, const uint8_t *next2_line,
55  const uint8_t *prev3_line, const uint8_t *next3_line,
56  int x, int width, int rslope, int redge,
57  int depth, int *K);
58 
59  unsigned (*mid_8[3])(const uint8_t *const prev,
60  const uint8_t *const next,
61  const uint8_t *const prev2,
62  const uint8_t *const next2,
63  const uint8_t *const prev3,
64  const uint8_t *const next3,
65  int end, int x, int k, int depth);
66 
67  unsigned (*mid_16[3])(const uint16_t *const prev,
68  const uint16_t *const next,
69  const uint16_t *const prev2,
70  const uint16_t *const next2,
71  const uint16_t *const prev3,
72  const uint16_t *const next3,
73  int end, int x, int k, int depth);
75 
76 #define MAX_R 15
77 #define S (MAX_R * 2 + 1)
78 
79 #define OFFSET(x) offsetof(ESTDIFContext, x)
80 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
81 #define CONST(name, help, val, u) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, 0, 0, FLAGS, .unit = u }
82 
83 static const AVOption estdif_options[] = {
84  { "mode", "specify the mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, .unit = "mode" },
85  CONST("frame", "send one frame for each frame", 0, "mode"),
86  CONST("field", "send one frame for each field", 1, "mode"),
87  { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=-1}, -1, 1, FLAGS, .unit = "parity" },
88  CONST("tff", "assume top field first", 0, "parity"),
89  CONST("bff", "assume bottom field first", 1, "parity"),
90  CONST("auto", "auto detect parity", -1, "parity"),
91  { "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "deint" },
92  CONST("all", "deinterlace all frames", 0, "deint"),
93  CONST("interlaced", "only deinterlace frames marked as interlaced", 1, "deint"),
94  { "rslope", "specify the search radius for edge slope tracing", OFFSET(rslope), AV_OPT_TYPE_INT, {.i64=1}, 1, MAX_R, FLAGS },
95  { "redge", "specify the search radius for best edge matching", OFFSET(redge), AV_OPT_TYPE_INT, {.i64=2}, 0, MAX_R, FLAGS },
96  { "ecost", "specify the edge cost for edge matching", OFFSET(ecost), AV_OPT_TYPE_INT, {.i64=2}, 0, 50, FLAGS },
97  { "mcost", "specify the middle cost for edge matching", OFFSET(mcost), AV_OPT_TYPE_INT, {.i64=1}, 0, 50, FLAGS },
98  { "dcost", "specify the distance cost for edge matching", OFFSET(dcost), AV_OPT_TYPE_INT, {.i64=1}, 0, 50, FLAGS },
99  { "interp", "specify the type of interpolation", OFFSET(interp), AV_OPT_TYPE_INT, {.i64=1}, 0, 2, FLAGS, .unit = "interp" },
100  CONST("2p", "two-point interpolation", 0, "interp"),
101  CONST("4p", "four-point interpolation", 1, "interp"),
102  CONST("6p", "six-point interpolation", 2, "interp"),
103  { NULL }
104 };
105 
106 AVFILTER_DEFINE_CLASS(estdif);
107 
108 static const enum AVPixelFormat pix_fmts[] = {
132 };
133 
134 static int config_output(AVFilterLink *outlink)
135 {
136  AVFilterContext *ctx = outlink->src;
137  AVFilterLink *inlink = ctx->inputs[0];
138  ESTDIFContext *s = ctx->priv;
139 
140  outlink->time_base = av_mul_q(inlink->time_base, (AVRational){1, 2});
141  if (s->mode)
142  outlink->frame_rate = av_mul_q(inlink->frame_rate, (AVRational){2, 1});
143 
144  return 0;
145 }
146 
147 typedef struct ThreadData {
148  AVFrame *out, *in;
149 } ThreadData;
150 
151 #define MIDL(type, ss) \
152 static unsigned midl_##ss(const type *const prev, \
153  const type *const next, \
154  int end, int x, int k) \
155 { \
156  return (prev[av_clip(x + k, 0, end)] + \
157  next[av_clip(x - k, 0, end)] + 1) >> 1; \
158 }
159 
160 MIDL(uint8_t, 8)
161 MIDL(uint16_t, 16)
162 
163 #define MID2(type, ss) \
164 static unsigned mid2_##ss(const type *const prev, \
165  const type *const next, \
166  const type *const prev2, \
167  const type *const next2, \
168  const type *const prev3, \
169  const type *const next3, \
170  int end, int x, int k, int depth) \
171 { \
172  return (prev[av_clip(x + k, 0, end)] + \
173  next[av_clip(x - k, 0, end)] + 1) >> 1; \
174 }
175 
176 MID2(uint8_t, 8)
177 MID2(uint16_t, 16)
178 
179 #define MID4(type, ss) \
180 static unsigned mid4_##ss(const type *const prev, \
181  const type *const next, \
182  const type *const prev2, \
183  const type *const next2, \
184  const type *const prev3, \
185  const type *const next3, \
186  int end, int x, int k, int depth) \
187 { \
188  return av_clip_uintp2_c(( \
189  9 * (prev[av_clip(x + k, 0, end)] + \
190  next[av_clip(x - k, 0, end)]) - \
191  1 * (prev2[av_clip(x + k*3, 0, end)] + \
192  next2[av_clip(x - k*3, 0, end)]) + 8) >> 4, \
193  depth); \
194 }
195 
196 MID4(uint8_t, 8)
197 MID4(uint16_t, 16)
198 
199 #define MID6(type, ss) \
200 static unsigned mid6_##ss(const type *const prev, \
201  const type *const next, \
202  const type *const prev2, \
203  const type *const next2, \
204  const type *const prev3, \
205  const type *const next3, \
206  int end, int x, int k, int depth) \
207 { \
208  return av_clip_uintp2_c(( \
209  20 * (prev[av_clip(x + k, 0, end)] + \
210  next[av_clip(x - k, 0, end)]) - \
211  5 * (prev2[av_clip(x + k*3, 0, end)] + \
212  next2[av_clip(x - k*3, 0, end)]) + \
213  1 * (prev3[av_clip(x + k*5, 0, end)] + \
214  next3[av_clip(x - k*5, 0, end)]) + 16) >> 5, \
215  depth); \
216 }
217 
218 MID6(uint8_t, 8)
219 MID6(uint16_t, 16)
220 
221 #define DIFF(type, ss) \
222 static unsigned diff_##ss(const type *const prev, \
223  const type *const next, \
224  int x, int y) \
225 { \
226  return FFABS(prev[x] - next[y]); \
227 }
228 
229 DIFF(uint8_t, 8)
230 DIFF(uint16_t, 16)
231 
232 #define COST(type, ss) \
233 static unsigned cost_##ss(const type *const prev, \
234  const type *const next, \
235  int end, int x, int k) \
236 { \
237  const int m = midl_##ss(prev, next, end, x, k); \
238  const int p = prev[x]; \
239  const int n = next[x]; \
240  \
241  return FFABS(p - m) + FFABS(n - m); \
242 }
243 
244 COST(uint8_t, 8)
245 COST(uint16_t, 16)
246 
247 #define INTERPOLATE(type, atype, amax, ss) \
248 static void interpolate_##ss(ESTDIFContext *s, uint8_t *ddst, \
249  const uint8_t *const pprev_line, \
250  const uint8_t *const nnext_line, \
251  const uint8_t *const pprev2_line, \
252  const uint8_t *const nnext2_line, \
253  const uint8_t *const pprev3_line, \
254  const uint8_t *const nnext3_line, \
255  int x, int width, int rslope, \
256  int redge, int depth, \
257  int *K) \
258 { \
259  type *dst = (type *)ddst; \
260  const type *const prev_line = (const type *const)pprev_line; \
261  const type *const prev2_line = (const type *const)pprev2_line; \
262  const type *const prev3_line = (const type *const)pprev3_line; \
263  const type *const next_line = (const type *const)nnext_line; \
264  const type *const next2_line = (const type *const)nnext2_line; \
265  const type *const next3_line = (const type *const)nnext3_line; \
266  const int interp = s->interp; \
267  const int ecost = s->ecost; \
268  const int dcost = s->dcost; \
269  const int mcost = s->mcost; \
270  atype sd[S], sD[S], di = 0; \
271  const int end = width - 1; \
272  atype dmin = amax; \
273  int id = 0, iD = 0; \
274  int k = *K; \
275  \
276  for (int i = -rslope; i <= rslope && abs(k) > rslope; i++) { \
277  atype sum = 0; \
278  \
279  for (int j = -redge; j <= redge; j++) { \
280  const int xx = av_clip(x + i + j, 0, end); \
281  const int yy = av_clip(x - i + j, 0, end); \
282  sum += diff_##ss(prev_line, next_line, xx, yy); \
283  sum += diff_##ss(prev2_line, prev_line, xx, yy); \
284  sum += diff_##ss(next_line, next2_line, xx, yy); \
285  } \
286  \
287  sD[i + rslope] = ecost * sum; \
288  sD[i + rslope] += mcost * cost_##ss(prev_line, next_line, end, x, i);\
289  sD[i + rslope] += dcost * abs(i); \
290  \
291  if (dmin > sD[i + rslope]) { \
292  dmin = sD[i + rslope]; \
293  di = 1; \
294  iD = i; \
295  } \
296  } \
297  \
298  for (int i = -rslope; i <= rslope; i++) { \
299  atype sum = 0; \
300  \
301  for (int j = -redge; j <= redge; j++) { \
302  const int xx = av_clip(x + k + i + j, 0, end); \
303  const int yy = av_clip(x - k - i + j, 0, end); \
304  sum += diff_##ss(prev_line, next_line, xx, yy); \
305  sum += diff_##ss(prev2_line, prev_line, xx, yy); \
306  sum += diff_##ss(next_line, next2_line, xx, yy); \
307  } \
308  \
309  sd[i + rslope] = ecost * sum; \
310  sd[i + rslope] += mcost * cost_##ss(prev_line, next_line, end, x, k+i);\
311  sd[i + rslope] += dcost * abs(k + i); \
312  \
313  if (dmin > sd[i + rslope]) { \
314  dmin = sd[i + rslope]; \
315  di = 0; \
316  id = i; \
317  } \
318  } \
319  \
320  k = di ? iD : k + id; \
321  \
322  dst[x] = s->mid_##ss[interp](prev_line, next_line, \
323  prev2_line, next2_line, \
324  prev3_line, next3_line, \
325  end, x, k, depth); \
326  \
327  *K = k; \
328 }
329 
330 INTERPOLATE(uint8_t, unsigned, UINT_MAX, 8)
331 INTERPOLATE(uint16_t, uint64_t, UINT64_MAX, 16)
332 
334  int jobnr, int nb_jobs)
335 {
336  ESTDIFContext *s = ctx->priv;
337  ThreadData *td = arg;
338  AVFrame *out = td->out;
339  AVFrame *in = td->in;
340  const int rslope = s->rslope;
341  const int redge = s->redge;
342  const int depth = s->depth;
343  const int interlaced = !!(in->flags & AV_FRAME_FLAG_INTERLACED);
344  const int tff = (s->field == (s->parity == -1 ? interlaced ? !!(in->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) : 1 :
345  s->parity ^ 1));
346 
347  for (int plane = 0; plane < s->nb_planes; plane++) {
348  const uint8_t *src_data = in->data[plane];
349  uint8_t *dst_data = out->data[plane];
350  const int linesize = s->linesize[plane];
351  const int width = s->planewidth[plane];
352  const int height = s->planeheight[plane];
353  const int src_linesize = in->linesize[plane];
354  const int dst_linesize = out->linesize[plane];
355  const int start = (height * jobnr) / nb_jobs;
356  const int end = (height * (jobnr+1)) / nb_jobs;
357  const uint8_t *prev_line, *prev2_line, *next_line, *next2_line, *in_line;
358  const uint8_t *prev3_line, *next3_line;
359  uint8_t *out_line;
360  int y_out;
361 
362  y_out = start + (tff ^ (start & 1));
363 
364  in_line = src_data + (y_out * src_linesize);
365  out_line = dst_data + (y_out * dst_linesize);
366 
367  while (y_out < end) {
368  memcpy(out_line, in_line, linesize);
369  y_out += 2;
370  in_line += src_linesize * 2;
371  out_line += dst_linesize * 2;
372  }
373 
374  y_out = start + ((!tff) ^ (start & 1));
375  out_line = dst_data + (y_out * dst_linesize);
376 
377  for (int y = y_out; y < end; y += 2) {
378  int y_prev3_in = y - 5;
379  int y_next3_in = y + 5;
380  int y_prev2_in = y - 3;
381  int y_next2_in = y + 3;
382  int y_prev_in = y - 1;
383  int y_next_in = y + 1;
384  int k;
385 
386  while (y_prev3_in < 0)
387  y_prev3_in += 2;
388 
389  while (y_next3_in >= height)
390  y_next3_in -= 2;
391 
392  while (y_prev2_in < 0)
393  y_prev2_in += 2;
394 
395  while (y_next2_in >= height)
396  y_next2_in -= 2;
397 
398  while (y_prev_in < 0)
399  y_prev_in += 2;
400 
401  while (y_next_in >= height)
402  y_next_in -= 2;
403 
404  prev3_line = src_data + (y_prev3_in * src_linesize);
405  next3_line = src_data + (y_next3_in * src_linesize);
406 
407  prev2_line = src_data + (y_prev2_in * src_linesize);
408  next2_line = src_data + (y_next2_in * src_linesize);
409 
410  prev_line = src_data + (y_prev_in * src_linesize);
411  next_line = src_data + (y_next_in * src_linesize);
412 
413  k = 0;
414 
415  for (int x = 0; x < width; x++) {
416  s->interpolate(s, out_line,
417  prev_line, next_line,
418  prev2_line, next2_line,
419  prev3_line, next3_line,
420  x, width, rslope, redge, depth, &k);
421  }
422 
423  out_line += 2 * dst_linesize;
424  }
425  }
426 
427  return 0;
428 }
429 
430 static int filter(AVFilterContext *ctx, AVFrame *in, int64_t pts, int64_t duration)
431 {
432  ESTDIFContext *s = ctx->priv;
433  AVFilterLink *outlink = ctx->outputs[0];
434  AVFrame *out;
435  ThreadData td;
436 
437  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
438  if (!out)
439  return AVERROR(ENOMEM);
441 #if FF_API_INTERLACED_FRAME
443  out->interlaced_frame = 0;
445 #endif
446  out->flags &= ~AV_FRAME_FLAG_INTERLACED;
447  out->pts = pts;
448  out->duration = duration;
449 
450  td.out = out; td.in = in;
452  FFMIN(s->planeheight[1] / 2, s->nb_threads));
453 
454  if (s->mode)
455  s->field = !s->field;
456 
457  return ff_filter_frame(outlink, out);
458 }
459 
461 {
462  AVFilterContext *ctx = inlink->dst;
463  ESTDIFContext *s = ctx->priv;
465  int ret;
466 
467  if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
468  return ret;
469 
470  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
471  s->planeheight[0] = s->planeheight[3] = inlink->h;
472  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
473  s->planewidth[0] = s->planewidth[3] = inlink->w;
474 
475  if (inlink->h < 3) {
476  av_log(ctx, AV_LOG_ERROR, "Video of less than 3 lines is not supported\n");
477  return AVERROR(EINVAL);
478  }
479 
480  s->nb_planes = av_pix_fmt_count_planes(inlink->format);
481  s->nb_threads = ff_filter_get_nb_threads(ctx);
482  s->depth = desc->comp[0].depth;
483  s->interpolate = s->depth <= 8 ? interpolate_8 : interpolate_16;
484  s->mid_8[0] = mid2_8;
485  s->mid_8[1] = mid4_8;
486  s->mid_8[2] = mid6_8;
487  s->mid_16[0] = mid2_16;
488  s->mid_16[1] = mid4_16;
489  s->mid_16[2] = mid6_16;
490  s->max = (1 << (s->depth)) - 1;
491 
492  return 0;
493 }
495 {
496  AVFilterContext *ctx = inlink->dst;
497  ESTDIFContext *s = ctx->priv;
498  int ret;
499 
500  if (!s->prev) {
501  s->prev = in;
502  return 0;
503  }
504 
505  if ((s->deint && !(s->prev->flags & AV_FRAME_FLAG_INTERLACED)) || ctx->is_disabled) {
506  s->prev->pts *= 2;
507  s->prev->duration *= 2;
508  ret = ff_filter_frame(ctx->outputs[0], s->prev);
509  s->prev = in;
510  return ret;
511  }
512 
513  ret = filter(ctx, s->prev, s->prev->pts * 2,
514  s->prev->duration * (s->mode ? 1 : 2));
515  if (ret < 0 || s->mode == 0) {
516  av_frame_free(&s->prev);
517  s->prev = in;
518  return ret;
519  }
520 
521  ret = filter(ctx, s->prev, s->prev->pts + in->pts, in->duration);
522  av_frame_free(&s->prev);
523  s->prev = in;
524  return ret;
525 }
526 
528 {
529  AVFilterContext *ctx = link->src;
530  ESTDIFContext *s = ctx->priv;
531  int ret;
532 
533  if (s->eof)
534  return AVERROR_EOF;
535 
536  ret = ff_request_frame(ctx->inputs[0]);
537 
538  if (ret == AVERROR_EOF && s->prev) {
539  AVFrame *next = av_frame_clone(s->prev);
540 
541  if (!next)
542  return AVERROR(ENOMEM);
543 
544  next->pts = s->prev->pts + av_rescale_q(1, av_inv_q(ctx->outputs[0]->frame_rate),
545  ctx->outputs[0]->time_base);
546  s->eof = 1;
547  ret = filter_frame(ctx->inputs[0], next);
548  } else if (ret < 0) {
549  return ret;
550  }
551 
552  return ret;
553 }
554 
556 {
557  ESTDIFContext *s = ctx->priv;
558 
559  av_frame_free(&s->prev);
560 }
561 
562 static const AVFilterPad estdif_inputs[] = {
563  {
564  .name = "default",
565  .type = AVMEDIA_TYPE_VIDEO,
566  .filter_frame = filter_frame,
567  .config_props = config_input,
568  },
569 };
570 
571 static const AVFilterPad estdif_outputs[] = {
572  {
573  .name = "default",
574  .type = AVMEDIA_TYPE_VIDEO,
575  .config_props = config_output,
576  .request_frame = request_frame,
577  },
578 };
579 
581  .name = "estdif",
582  .description = NULL_IF_CONFIG_SMALL("Apply Edge Slope Tracing deinterlace."),
583  .priv_size = sizeof(ESTDIFContext),
584  .priv_class = &estdif_class,
585  .uninit = uninit,
590  .process_command = ff_filter_process_command,
591 };
ESTDIFContext::nb_planes
int nb_planes
Definition: vf_estdif.c:48
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:112
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:526
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:505
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
ESTDIFContext::mcost
int mcost
middle cost for edge matching
Definition: vf_estdif.c:38
td
#define td
Definition: regdef.h:70
ESTDIFContext::interpolate
void(* interpolate)(struct ESTDIFContext *s, uint8_t *dst, const uint8_t *prev_line, const uint8_t *next_line, const uint8_t *prev2_line, const uint8_t *next2_line, const uint8_t *prev3_line, const uint8_t *next3_line, int x, int width, int rslope, int redge, int depth, int *K)
Definition: vf_estdif.c:52
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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
MID6
#define MID6(type, ss)
Definition: vf_estdif.c:199
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:807
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
deinterlace_slice
static int deinterlace_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_estdif.c:333
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
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
estdif_inputs
static const AVFilterPad estdif_inputs[]
Definition: vf_estdif.c:562
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:518
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
ESTDIFContext::parity
int parity
frame field parity
Definition: vf_estdif.c:33
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:525
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:520
AVOption
AVOption.
Definition: opt.h:294
ESTDIFContext::mid_16
unsigned(* mid_16[3])(const uint16_t *const prev, const uint16_t *const next, const uint16_t *const prev2, const uint16_t *const next2, const uint16_t *const prev3, const uint16_t *const next3, int end, int x, int k, int depth)
Definition: vf_estdif.c:67
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_estdif.c:494
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:482
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:451
MIDL
#define MIDL(type, ss)
Definition: vf_estdif.c:151
DIFF
#define DIFF(type, ss)
Definition: vf_estdif.c:221
ESTDIFContext::deint
int deint
which frames to deinterlace
Definition: vf_estdif.c:34
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
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:526
video.h
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:153
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:521
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:462
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:641
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3008
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:517
MID4
#define MID4(type, ss)
Definition: vf_estdif.c:179
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:500
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_estdif.c:108
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
interp
interp
Definition: vf_curves.c:61
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:498
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_estdif.c:134
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:527
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:480
pts
static int64_t pts
Definition: transcode_aac.c:643
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:466
ESTDIFContext::ecost
int ecost
edge cost for edge matching
Definition: vf_estdif.c:37
ESTDIFContext::max
int max
Definition: vf_estdif.c:47
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:485
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:283
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:494
duration
int64_t duration
Definition: movenc.c:64
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:502
width
#define width
av_image_fill_linesizes
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:503
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
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:495
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
ESTDIFContext::field
int field
which field are we on, 0 or 1
Definition: vf_estdif.c:44
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:524
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:479
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:493
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:465
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:609
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
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
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_estdif.c:460
link
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 link
Definition: filter_design.txt:23
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
ESTDIFContext::mode
int mode
0 is frame, 1 is field
Definition: vf_estdif.c:32
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:463
ESTDIFContext::interp
int interp
type of interpolation
Definition: vf_estdif.c:40
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:501
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:736
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
ESTDIFContext::eof
int eof
Definition: vf_estdif.c:45
MID2
#define MID2(type, ss)
Definition: vf_estdif.c:163
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:484
COST
#define COST(type, ss)
Definition: vf_estdif.c:232
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_estdif.c:555
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:483
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
estdif_outputs
static const AVFilterPad estdif_outputs[]
Definition: vf_estdif.c:571
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:497
ESTDIFContext::dcost
int dcost
distance cost for edge matching
Definition: vf_estdif.c:39
ESTDIFContext::linesize
int linesize[4]
bytes of pixel data per line for each plane
Definition: vf_estdif.c:41
FLAGS
#define FLAGS
Definition: vf_estdif.c:80
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:106
ESTDIFContext::mid_8
unsigned(* mid_8[3])(const uint8_t *const prev, const uint8_t *const next, const uint8_t *const prev2, const uint8_t *const next2, const uint8_t *const prev3, const uint8_t *const next3, int end, int x, int k, int depth)
Definition: vf_estdif.c:59
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:487
CONST
#define CONST(name, help, val, u)
Definition: vf_estdif.c:81
parity
mcdeint parity
Definition: vf_mcdeint.c:281
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:489
ESTDIFContext
Definition: vf_estdif.c:29
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:879
ESTDIFContext::depth
int depth
Definition: vf_estdif.c:46
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:174
INTERPOLATE
#define INTERPOLATE(type, atype, amax, ss)
Definition: vf_estdif.c:247
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:522
OFFSET
#define OFFSET(x)
Definition: vf_estdif.c:79
internal.h
interlaced
uint8_t interlaced
Definition: mxfenc.c:2263
ff_vf_estdif
const AVFilter ff_vf_estdif
Definition: vf_estdif.c:580
filter
static int filter(AVFilterContext *ctx, AVFrame *in, int64_t pts, int64_t duration)
Definition: vf_estdif.c:430
ESTDIFContext::planeheight
int planeheight[4]
height of each plane
Definition: vf_estdif.c:43
MAX_R
#define MAX_R
Definition: vf_estdif.c:76
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:499
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:814
ThreadData
Used for passing data between threads.
Definition: dsddec.c:69
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:107
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:636
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:481
AVFilter
Filter definition.
Definition: avfilter.h:166
estdif_options
static const AVOption estdif_options[]
Definition: vf_estdif.c:83
ret
ret
Definition: filter_design.txt:187
ESTDIFContext::nb_threads
int nb_threads
Definition: vf_estdif.c:49
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:519
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:486
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:491
request_frame
static int request_frame(AVFilterLink *link)
Definition: vf_estdif.c:527
mode
mode
Definition: ebur128.h:83
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:523
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
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:409
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ESTDIFContext::prev
AVFrame * prev
Definition: vf_estdif.c:50
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
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
K
#define K
Definition: palette.c:25
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:155
imgutils.h
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(estdif)
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:385
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
ESTDIFContext::redge
int redge
best edge match search radius
Definition: vf_estdif.c:36
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:488
ESTDIFContext::planewidth
int planewidth[4]
width of each plane
Definition: vf_estdif.c:42
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:492
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:464
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:134
ESTDIFContext::rslope
int rslope
best edge slope search radius
Definition: vf_estdif.c:35
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
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:490