FFmpeg  4.4.6
vf_w3fdif.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 British Broadcasting Corporation, All Rights Reserved
3  * Author of de-interlace algorithm: Jim Easterbrook for BBC R&D
4  * Based on the process described by Martin Weston for BBC R&D
5  * Author of FFmpeg filter: Mark Himsley for BBC Broadcast Systems Development
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "libavutil/common.h"
25 #include "libavutil/imgutils.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
28 #include "avfilter.h"
29 #include "formats.h"
30 #include "internal.h"
31 #include "video.h"
32 #include "w3fdif.h"
33 
34 typedef struct W3FDIFContext {
35  const AVClass *class;
36  int filter; ///< 0 is simple, 1 is more complex
37  int mode; ///< 0 is frame, 1 is field
38  int parity; ///< frame field parity
39  int deint; ///< which frames to deinterlace
40  int linesize[4]; ///< bytes of pixel data per line for each plane
41  int planeheight[4]; ///< height of each plane
42  int field; ///< which field are we on, 0 or 1
43  int eof;
44  int nb_planes;
45  AVFrame *prev, *cur, *next; ///< previous, current, next frames
46  int32_t **work_line; ///< lines we are calculating
48  int max;
49 
52 
53 #define OFFSET(x) offsetof(W3FDIFContext, x)
54 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
55 #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, 0, 0, FLAGS, unit }
56 
57 static const AVOption w3fdif_options[] = {
58  { "filter", "specify the filter", OFFSET(filter), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "filter" },
59  CONST("simple", NULL, 0, "filter"),
60  CONST("complex", NULL, 1, "filter"),
61  { "mode", "specify the interlacing mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "mode"},
62  CONST("frame", "send one frame for each frame", 0, "mode"),
63  CONST("field", "send one frame for each field", 1, "mode"),
64  { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=-1}, -1, 1, FLAGS, "parity" },
65  CONST("tff", "assume top field first", 0, "parity"),
66  CONST("bff", "assume bottom field first", 1, "parity"),
67  CONST("auto", "auto detect parity", -1, "parity"),
68  { "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "deint" },
69  CONST("all", "deinterlace all frames", 0, "deint"),
70  CONST("interlaced", "only deinterlace frames marked as interlaced", 1, "deint"),
71  { NULL }
72 };
73 
75 
77 {
78  static const enum AVPixelFormat pix_fmts[] = {
102  };
103 
105  if (!fmts_list)
106  return AVERROR(ENOMEM);
107  return ff_set_common_formats(ctx, fmts_list);
108 }
109 
110 static void filter_simple_low(int32_t *work_line,
111  uint8_t *in_lines_cur[2],
112  const int16_t *coef, int linesize)
113 {
114  int i;
115 
116  for (i = 0; i < linesize; i++) {
117  *work_line = *in_lines_cur[0]++ * coef[0];
118  *work_line++ += *in_lines_cur[1]++ * coef[1];
119  }
120 }
121 
122 static void filter_complex_low(int32_t *work_line,
123  uint8_t *in_lines_cur[4],
124  const int16_t *coef, int linesize)
125 {
126  int i;
127 
128  for (i = 0; i < linesize; i++) {
129  *work_line = *in_lines_cur[0]++ * coef[0];
130  *work_line += *in_lines_cur[1]++ * coef[1];
131  *work_line += *in_lines_cur[2]++ * coef[2];
132  *work_line++ += *in_lines_cur[3]++ * coef[3];
133  }
134 }
135 
136 static void filter_simple_high(int32_t *work_line,
137  uint8_t *in_lines_cur[3],
138  uint8_t *in_lines_adj[3],
139  const int16_t *coef, int linesize)
140 {
141  int i;
142 
143  for (i = 0; i < linesize; i++) {
144  *work_line += *in_lines_cur[0]++ * coef[0];
145  *work_line += *in_lines_adj[0]++ * coef[0];
146  *work_line += *in_lines_cur[1]++ * coef[1];
147  *work_line += *in_lines_adj[1]++ * coef[1];
148  *work_line += *in_lines_cur[2]++ * coef[2];
149  *work_line++ += *in_lines_adj[2]++ * coef[2];
150  }
151 }
152 
153 static void filter_complex_high(int32_t *work_line,
154  uint8_t *in_lines_cur[5],
155  uint8_t *in_lines_adj[5],
156  const int16_t *coef, int linesize)
157 {
158  int i;
159 
160  for (i = 0; i < linesize; i++) {
161  *work_line += *in_lines_cur[0]++ * coef[0];
162  *work_line += *in_lines_adj[0]++ * coef[0];
163  *work_line += *in_lines_cur[1]++ * coef[1];
164  *work_line += *in_lines_adj[1]++ * coef[1];
165  *work_line += *in_lines_cur[2]++ * coef[2];
166  *work_line += *in_lines_adj[2]++ * coef[2];
167  *work_line += *in_lines_cur[3]++ * coef[3];
168  *work_line += *in_lines_adj[3]++ * coef[3];
169  *work_line += *in_lines_cur[4]++ * coef[4];
170  *work_line++ += *in_lines_adj[4]++ * coef[4];
171  }
172 }
173 
174 static void filter_scale(uint8_t *out_pixel, const int32_t *work_pixel, int linesize, int max)
175 {
176  int j;
177 
178  for (j = 0; j < linesize; j++, out_pixel++, work_pixel++)
179  *out_pixel = av_clip(*work_pixel, 0, 255 * 256 * 128) >> 15;
180 }
181 
182 static void filter16_simple_low(int32_t *work_line,
183  uint8_t *in_lines_cur8[2],
184  const int16_t *coef, int linesize)
185 {
186  uint16_t *in_lines_cur[2] = { (uint16_t *)in_lines_cur8[0], (uint16_t *)in_lines_cur8[1] };
187  int i;
188 
189  linesize /= 2;
190  for (i = 0; i < linesize; i++) {
191  *work_line = *in_lines_cur[0]++ * coef[0];
192  *work_line++ += *in_lines_cur[1]++ * coef[1];
193  }
194 }
195 
196 static void filter16_complex_low(int32_t *work_line,
197  uint8_t *in_lines_cur8[4],
198  const int16_t *coef, int linesize)
199 {
200  uint16_t *in_lines_cur[4] = { (uint16_t *)in_lines_cur8[0],
201  (uint16_t *)in_lines_cur8[1],
202  (uint16_t *)in_lines_cur8[2],
203  (uint16_t *)in_lines_cur8[3] };
204  int i;
205 
206  linesize /= 2;
207  for (i = 0; i < linesize; i++) {
208  *work_line = *in_lines_cur[0]++ * coef[0];
209  *work_line += *in_lines_cur[1]++ * coef[1];
210  *work_line += *in_lines_cur[2]++ * coef[2];
211  *work_line++ += *in_lines_cur[3]++ * coef[3];
212  }
213 }
214 
215 static void filter16_simple_high(int32_t *work_line,
216  uint8_t *in_lines_cur8[3],
217  uint8_t *in_lines_adj8[3],
218  const int16_t *coef, int linesize)
219 {
220  uint16_t *in_lines_cur[3] = { (uint16_t *)in_lines_cur8[0],
221  (uint16_t *)in_lines_cur8[1],
222  (uint16_t *)in_lines_cur8[2] };
223  uint16_t *in_lines_adj[3] = { (uint16_t *)in_lines_adj8[0],
224  (uint16_t *)in_lines_adj8[1],
225  (uint16_t *)in_lines_adj8[2] };
226  int i;
227 
228  linesize /= 2;
229  for (i = 0; i < linesize; i++) {
230  *work_line += *in_lines_cur[0]++ * coef[0];
231  *work_line += *in_lines_adj[0]++ * coef[0];
232  *work_line += *in_lines_cur[1]++ * coef[1];
233  *work_line += *in_lines_adj[1]++ * coef[1];
234  *work_line += *in_lines_cur[2]++ * coef[2];
235  *work_line++ += *in_lines_adj[2]++ * coef[2];
236  }
237 }
238 
239 static void filter16_complex_high(int32_t *work_line,
240  uint8_t *in_lines_cur8[5],
241  uint8_t *in_lines_adj8[5],
242  const int16_t *coef, int linesize)
243 {
244  uint16_t *in_lines_cur[5] = { (uint16_t *)in_lines_cur8[0],
245  (uint16_t *)in_lines_cur8[1],
246  (uint16_t *)in_lines_cur8[2],
247  (uint16_t *)in_lines_cur8[3],
248  (uint16_t *)in_lines_cur8[4] };
249  uint16_t *in_lines_adj[5] = { (uint16_t *)in_lines_adj8[0],
250  (uint16_t *)in_lines_adj8[1],
251  (uint16_t *)in_lines_adj8[2],
252  (uint16_t *)in_lines_adj8[3],
253  (uint16_t *)in_lines_adj8[4] };
254  int i;
255 
256  linesize /= 2;
257  for (i = 0; i < linesize; i++) {
258  *work_line += *in_lines_cur[0]++ * coef[0];
259  *work_line += *in_lines_adj[0]++ * coef[0];
260  *work_line += *in_lines_cur[1]++ * coef[1];
261  *work_line += *in_lines_adj[1]++ * coef[1];
262  *work_line += *in_lines_cur[2]++ * coef[2];
263  *work_line += *in_lines_adj[2]++ * coef[2];
264  *work_line += *in_lines_cur[3]++ * coef[3];
265  *work_line += *in_lines_adj[3]++ * coef[3];
266  *work_line += *in_lines_cur[4]++ * coef[4];
267  *work_line++ += *in_lines_adj[4]++ * coef[4];
268  }
269 }
270 
271 static void filter16_scale(uint8_t *out_pixel8, const int32_t *work_pixel, int linesize, int max)
272 {
273  uint16_t *out_pixel = (uint16_t *)out_pixel8;
274  int j;
275 
276  linesize /= 2;
277  for (j = 0; j < linesize; j++, out_pixel++, work_pixel++)
278  *out_pixel = av_clip(*work_pixel, 0, max) >> 15;
279 }
280 
281 static int config_input(AVFilterLink *inlink)
282 {
283  AVFilterContext *ctx = inlink->dst;
284  W3FDIFContext *s = ctx->priv;
286  int ret, i, depth, nb_threads;
287 
288  if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
289  return ret;
290 
291  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
292  s->planeheight[0] = s->planeheight[3] = inlink->h;
293 
294  if (inlink->h < 3) {
295  av_log(ctx, AV_LOG_ERROR, "Video of less than 3 lines is not supported\n");
296  return AVERROR(EINVAL);
297  }
298 
299  s->nb_planes = av_pix_fmt_count_planes(inlink->format);
300  nb_threads = ff_filter_get_nb_threads(ctx);
301  s->work_line = av_calloc(nb_threads, sizeof(*s->work_line));
302  if (!s->work_line)
303  return AVERROR(ENOMEM);
304  s->nb_threads = nb_threads;
305 
306  for (i = 0; i < s->nb_threads; i++) {
307  s->work_line[i] = av_calloc(FFALIGN(s->linesize[0], 32), sizeof(*s->work_line[0]));
308  if (!s->work_line[i])
309  return AVERROR(ENOMEM);
310  }
311 
312  depth = desc->comp[0].depth;
313  s->max = ((1 << depth) - 1) * 256 * 128;
314  if (depth <= 8) {
315  s->dsp.filter_simple_low = filter_simple_low;
316  s->dsp.filter_complex_low = filter_complex_low;
317  s->dsp.filter_simple_high = filter_simple_high;
318  s->dsp.filter_complex_high = filter_complex_high;
319  s->dsp.filter_scale = filter_scale;
320  } else {
321  s->dsp.filter_simple_low = filter16_simple_low;
322  s->dsp.filter_complex_low = filter16_complex_low;
323  s->dsp.filter_simple_high = filter16_simple_high;
324  s->dsp.filter_complex_high = filter16_complex_high;
325  s->dsp.filter_scale = filter16_scale;
326  }
327 
328  if (ARCH_X86)
329  ff_w3fdif_init_x86(&s->dsp, depth);
330 
331  return 0;
332 }
333 
334 static int config_output(AVFilterLink *outlink)
335 {
336  AVFilterLink *inlink = outlink->src->inputs[0];
337 
338  outlink->time_base.num = inlink->time_base.num;
339  outlink->time_base.den = inlink->time_base.den * 2;
340  outlink->frame_rate.num = inlink->frame_rate.num * 2;
341  outlink->frame_rate.den = inlink->frame_rate.den;
342 
343  return 0;
344 }
345 
346 /*
347  * Filter coefficients from PH-2071, scaled by 256 * 128.
348  * Each set of coefficients has a set for low-frequencies and high-frequencies.
349  * n_coef_lf[] and n_coef_hf[] are the number of coefs for simple and more-complex.
350  * It is important for later that n_coef_lf[] is even and n_coef_hf[] is odd.
351  * coef_lf[][] and coef_hf[][] are the coefficients for low-frequencies
352  * and high-frequencies for simple and more-complex mode.
353  */
354 static const int8_t n_coef_lf[2] = { 2, 4 };
355 static const int16_t coef_lf[2][4] = {{ 16384, 16384, 0, 0},
356  { -852, 17236, 17236, -852}};
357 static const int8_t n_coef_hf[2] = { 3, 5 };
358 static const int16_t coef_hf[2][5] = {{ -2048, 4096, -2048, 0, 0},
359  { 1016, -3801, 5570, -3801, 1016}};
360 
361 typedef struct ThreadData {
363 } ThreadData;
364 
366  int jobnr, int nb_jobs, int plane)
367 {
368  W3FDIFContext *s = ctx->priv;
369  ThreadData *td = arg;
370  AVFrame *out = td->out;
371  AVFrame *cur = td->cur;
372  AVFrame *adj = td->adj;
373  const int filter = s->filter;
374  uint8_t *in_line, *in_lines_cur[5], *in_lines_adj[5];
375  uint8_t *out_line, *out_pixel;
376  int32_t *work_line, *work_pixel;
377  uint8_t *cur_data = cur->data[plane];
378  uint8_t *adj_data = adj->data[plane];
379  uint8_t *dst_data = out->data[plane];
380  const int linesize = s->linesize[plane];
381  const int height = s->planeheight[plane];
382  const int cur_line_stride = cur->linesize[plane];
383  const int adj_line_stride = adj->linesize[plane];
384  const int dst_line_stride = out->linesize[plane];
385  const int start = (height * jobnr) / nb_jobs;
386  const int end = (height * (jobnr+1)) / nb_jobs;
387  const int max = s->max;
388  const int interlaced = cur->interlaced_frame;
389  const int tff = s->field == (s->parity == -1 ? interlaced ? cur->top_field_first : 1 :
390  s->parity ^ 1);
391  int j, y_in, y_out;
392 
393  /* copy unchanged the lines of the field */
394  y_out = start + (tff ^ (start & 1));
395 
396  in_line = cur_data + (y_out * cur_line_stride);
397  out_line = dst_data + (y_out * dst_line_stride);
398 
399  while (y_out < end) {
400  memcpy(out_line, in_line, linesize);
401  y_out += 2;
402  in_line += cur_line_stride * 2;
403  out_line += dst_line_stride * 2;
404  }
405 
406  /* interpolate other lines of the field */
407  y_out = start + ((!tff) ^ (start & 1));
408 
409  out_line = dst_data + (y_out * dst_line_stride);
410 
411  while (y_out < end) {
412  /* get low vertical frequencies from current field */
413  for (j = 0; j < n_coef_lf[filter]; j++) {
414  y_in = (y_out + 1) + (j * 2) - n_coef_lf[filter];
415 
416  while (y_in < 0)
417  y_in += 2;
418  while (y_in >= height)
419  y_in -= 2;
420 
421  in_lines_cur[j] = cur_data + (y_in * cur_line_stride);
422  }
423 
424  work_line = s->work_line[jobnr];
425  switch (n_coef_lf[filter]) {
426  case 2:
427  s->dsp.filter_simple_low(work_line, in_lines_cur,
428  coef_lf[filter], linesize);
429  break;
430  case 4:
431  s->dsp.filter_complex_low(work_line, in_lines_cur,
432  coef_lf[filter], linesize);
433  }
434 
435  /* get high vertical frequencies from adjacent fields */
436  for (j = 0; j < n_coef_hf[filter]; j++) {
437  y_in = (y_out + 1) + (j * 2) - n_coef_hf[filter];
438 
439  while (y_in < 0)
440  y_in += 2;
441  while (y_in >= height)
442  y_in -= 2;
443 
444  in_lines_cur[j] = cur_data + (y_in * cur_line_stride);
445  in_lines_adj[j] = adj_data + (y_in * adj_line_stride);
446  }
447 
448  work_line = s->work_line[jobnr];
449  switch (n_coef_hf[filter]) {
450  case 3:
451  s->dsp.filter_simple_high(work_line, in_lines_cur, in_lines_adj,
452  coef_hf[filter], linesize);
453  break;
454  case 5:
455  s->dsp.filter_complex_high(work_line, in_lines_cur, in_lines_adj,
456  coef_hf[filter], linesize);
457  }
458 
459  /* save scaled result to the output frame, scaling down by 256 * 128 */
460  work_pixel = s->work_line[jobnr];
461  out_pixel = out_line;
462 
463  s->dsp.filter_scale(out_pixel, work_pixel, linesize, max);
464 
465  /* move on to next line */
466  y_out += 2;
467  out_line += dst_line_stride * 2;
468  }
469 
470  return 0;
471 }
472 
474  int jobnr, int nb_jobs)
475 {
476  W3FDIFContext *s = ctx->priv;
477 
478  for (int p = 0; p < s->nb_planes; p++)
479  deinterlace_plane_slice(ctx, arg, jobnr, nb_jobs, p);
480 
481  return 0;
482 }
483 
484 static int filter(AVFilterContext *ctx, int is_second)
485 {
486  W3FDIFContext *s = ctx->priv;
487  AVFilterLink *outlink = ctx->outputs[0];
488  AVFrame *out, *adj;
489  ThreadData td;
490 
491  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
492  if (!out)
493  return AVERROR(ENOMEM);
494  av_frame_copy_props(out, s->cur);
495  out->interlaced_frame = 0;
496 
497  if (!is_second) {
498  if (out->pts != AV_NOPTS_VALUE)
499  out->pts *= 2;
500  } else {
501  int64_t cur_pts = s->cur->pts;
502  int64_t next_pts = s->next->pts;
503 
504  if (next_pts != AV_NOPTS_VALUE && cur_pts != AV_NOPTS_VALUE) {
505  out->pts = cur_pts + next_pts;
506  } else {
507  out->pts = AV_NOPTS_VALUE;
508  }
509  }
510 
511  adj = s->field ? s->next : s->prev;
512  td.out = out; td.cur = s->cur; td.adj = adj;
513  ctx->internal->execute(ctx, deinterlace_slice, &td, NULL, FFMIN(s->planeheight[1], s->nb_threads));
514 
515  if (s->mode)
516  s->field = !s->field;
517 
518  return ff_filter_frame(outlink, out);
519 }
520 
521 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
522 {
523  AVFilterContext *ctx = inlink->dst;
524  W3FDIFContext *s = ctx->priv;
525  int ret;
526 
527  av_frame_free(&s->prev);
528  s->prev = s->cur;
529  s->cur = s->next;
530  s->next = frame;
531 
532  if (!s->cur) {
533  s->cur = av_frame_clone(s->next);
534  if (!s->cur)
535  return AVERROR(ENOMEM);
536  }
537 
538  if ((s->deint && !s->cur->interlaced_frame) || ctx->is_disabled) {
539  AVFrame *out = av_frame_clone(s->cur);
540  if (!out)
541  return AVERROR(ENOMEM);
542 
543  av_frame_free(&s->prev);
544  if (out->pts != AV_NOPTS_VALUE)
545  out->pts *= 2;
546  return ff_filter_frame(ctx->outputs[0], out);
547  }
548 
549  if (!s->prev)
550  return 0;
551 
552  ret = filter(ctx, 0);
553  if (ret < 0 || s->mode == 0)
554  return ret;
555 
556  return filter(ctx, 1);
557 }
558 
559 static int request_frame(AVFilterLink *outlink)
560 {
561  AVFilterContext *ctx = outlink->src;
562  W3FDIFContext *s = ctx->priv;
563  int ret;
564 
565  if (s->eof)
566  return AVERROR_EOF;
567 
568  ret = ff_request_frame(ctx->inputs[0]);
569 
570  if (ret == AVERROR_EOF && s->cur) {
571  AVFrame *next = av_frame_clone(s->next);
572  if (!next)
573  return AVERROR(ENOMEM);
574  next->pts = s->next->pts * 2 - s->cur->pts;
575  filter_frame(ctx->inputs[0], next);
576  s->eof = 1;
577  } else if (ret < 0) {
578  return ret;
579  }
580 
581  return 0;
582 }
583 
585 {
586  W3FDIFContext *s = ctx->priv;
587  int i;
588 
589  av_frame_free(&s->prev);
590  av_frame_free(&s->cur );
591  av_frame_free(&s->next);
592 
593  for (i = 0; i < s->nb_threads; i++)
594  av_freep(&s->work_line[i]);
595 
596  av_freep(&s->work_line);
597 }
598 
599 static const AVFilterPad w3fdif_inputs[] = {
600  {
601  .name = "default",
602  .type = AVMEDIA_TYPE_VIDEO,
603  .filter_frame = filter_frame,
604  .config_props = config_input,
605  },
606  { NULL }
607 };
608 
609 static const AVFilterPad w3fdif_outputs[] = {
610  {
611  .name = "default",
612  .type = AVMEDIA_TYPE_VIDEO,
613  .config_props = config_output,
614  .request_frame = request_frame,
615  },
616  { NULL }
617 };
618 
620  .name = "w3fdif",
621  .description = NULL_IF_CONFIG_SMALL("Apply Martin Weston three field deinterlace."),
622  .priv_size = sizeof(W3FDIFContext),
623  .priv_class = &w3fdif_class,
624  .uninit = uninit,
630 };
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_acrusher.c:336
#define av_cold
Definition: attributes.h:88
uint8_t
int32_t
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1096
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:882
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:408
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
Main libavfilter public API header.
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define s(width, name)
Definition: cbs_vp9.c:257
common internal and external API header
#define FFMIN(a, b)
Definition: common.h:105
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
#define av_clip
Definition: common.h:122
#define ARCH_X86
Definition: config.h:39
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
#define max(a, b)
Definition: cuda_runtime.h:33
static AVFrame * frame
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:587
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
@ AV_OPT_TYPE_INT
Definition: opt.h:225
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
#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:134
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:658
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
misc image utilities
int i
Definition: input.c:407
const char * arg
Definition: jacosubdec.c:66
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
const char * desc
Definition: libsvtav1.c:79
#define FFALIGN(x, a)
Definition: macros.h:48
uint8_t interlaced
Definition: mxfenc.c:2208
AVOptions.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2613
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:410
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:405
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:379
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:421
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:441
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:434
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:381
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:433
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
@ 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_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
@ 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:258
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
@ 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:79
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
@ 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:80
@ 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:78
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:439
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:382
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:401
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:435
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:440
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
#define td
Definition: regdef.h:70
Describe the class of an AVClass context structure.
Definition: log.h:67
An instance of a filter.
Definition: avfilter.h:341
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:349
A list of supported formats for one end of a filter link.
Definition: formats.h:65
A filter pad used for either input or output.
Definition: internal.h:54
const char * name
Pad name.
Definition: internal.h:60
Filter definition.
Definition: avfilter.h:145
const char * name
Filter name.
Definition: avfilter.h:149
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1699
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:470
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:465
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
AVOption.
Definition: opt.h:248
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
Used for passing data between threads.
Definition: dsddec.c:67
AVFrame * out
Definition: af_adeclick.c:502
AVFrame * cur
Definition: vf_w3fdif.c:362
AVFrame * adj
Definition: vf_w3fdif.c:362
int deint
which frames to deinterlace
Definition: vf_w3fdif.c:39
int32_t ** work_line
lines we are calculating
Definition: vf_w3fdif.c:46
int linesize[4]
bytes of pixel data per line for each plane
Definition: vf_w3fdif.c:40
W3FDIFDSPContext dsp
Definition: vf_w3fdif.c:50
int mode
0 is frame, 1 is field
Definition: vf_w3fdif.c:37
int parity
frame field parity
Definition: vf_w3fdif.c:38
int nb_threads
Definition: vf_w3fdif.c:47
AVFrame * prev
Definition: vf_w3fdif.c:45
AVFrame * next
previous, current, next frames
Definition: vf_w3fdif.c:45
int planeheight[4]
height of each plane
Definition: vf_w3fdif.c:41
int filter
0 is simple, 1 is more complex
Definition: vf_w3fdif.c:36
int field
which field are we on, 0 or 1
Definition: vf_w3fdif.c:42
AVFrame * cur
Definition: vf_w3fdif.c:45
#define av_freep(p)
#define av_log(a,...)
FILE * out
Definition: movenc.c:54
AVFormatContext * ctx
Definition: movenc.c:48
#define height
mcdeint parity
Definition: vf_mcdeint.c:277
static int deinterlace_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_w3fdif.c:473
AVFILTER_DEFINE_CLASS(w3fdif)
static void filter_complex_low(int32_t *work_line, uint8_t *in_lines_cur[4], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:122
static int deinterlace_plane_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs, int plane)
Definition: vf_w3fdif.c:365
static const int8_t n_coef_hf[2]
Definition: vf_w3fdif.c:357
static const int8_t n_coef_lf[2]
Definition: vf_w3fdif.c:354
static const int16_t coef_lf[2][4]
Definition: vf_w3fdif.c:355
#define CONST(name, help, val, unit)
Definition: vf_w3fdif.c:55
static int query_formats(AVFilterContext *ctx)
Definition: vf_w3fdif.c:76
static int config_input(AVFilterLink *inlink)
Definition: vf_w3fdif.c:281
static const AVOption w3fdif_options[]
Definition: vf_w3fdif.c:57
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_w3fdif.c:521
static void filter16_simple_high(int32_t *work_line, uint8_t *in_lines_cur8[3], uint8_t *in_lines_adj8[3], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:215
#define FLAGS
Definition: vf_w3fdif.c:54
static int request_frame(AVFilterLink *outlink)
Definition: vf_w3fdif.c:559
static const AVFilterPad w3fdif_inputs[]
Definition: vf_w3fdif.c:599
static void filter_scale(uint8_t *out_pixel, const int32_t *work_pixel, int linesize, int max)
Definition: vf_w3fdif.c:174
static const AVFilterPad w3fdif_outputs[]
Definition: vf_w3fdif.c:609
static int filter(AVFilterContext *ctx, int is_second)
Definition: vf_w3fdif.c:484
static void filter_simple_high(int32_t *work_line, uint8_t *in_lines_cur[3], uint8_t *in_lines_adj[3], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:136
static void filter16_scale(uint8_t *out_pixel8, const int32_t *work_pixel, int linesize, int max)
Definition: vf_w3fdif.c:271
static void filter16_simple_low(int32_t *work_line, uint8_t *in_lines_cur8[2], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:182
static void filter16_complex_high(int32_t *work_line, uint8_t *in_lines_cur8[5], uint8_t *in_lines_adj8[5], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:239
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_w3fdif.c:584
static void filter16_complex_low(int32_t *work_line, uint8_t *in_lines_cur8[4], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:196
static void filter_complex_high(int32_t *work_line, uint8_t *in_lines_cur[5], uint8_t *in_lines_adj[5], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:153
static const int16_t coef_hf[2][5]
Definition: vf_w3fdif.c:358
#define OFFSET(x)
Definition: vf_w3fdif.c:53
static int config_output(AVFilterLink *outlink)
Definition: vf_w3fdif.c:334
AVFilter ff_vf_w3fdif
Definition: vf_w3fdif.c:619
static void filter_simple_low(int32_t *work_line, uint8_t *in_lines_cur[2], const int16_t *coef, int linesize)
Definition: vf_w3fdif.c:110
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:104
void ff_w3fdif_init_x86(W3FDIFDSPContext *dsp, int depth)