FFmpeg
vf_bwdif.c
Go to the documentation of this file.
1 /*
2  * BobWeaver Deinterlacing Filter
3  * Copyright (C) 2016 Thomas Mundt <loudmax@yahoo.de>
4  *
5  * Based on YADIF (Yet Another Deinterlacing Filter)
6  * Copyright (C) 2006-2011 Michael Niedermayer <michaelni@gmx.at>
7  * 2010 James Darnley <james.darnley@gmail.com>
8  *
9  * With use of Weston 3 Field Deinterlacing Filter algorithm
10  * Copyright (C) 2012 British Broadcasting Corporation, All Rights Reserved
11  * Author of de-interlace algorithm: Jim Easterbrook for BBC R&D
12  * Based on the process described by Martin Weston for BBC R&D
13  *
14  * This file is part of FFmpeg.
15  *
16  * FFmpeg is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * FFmpeg is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with FFmpeg; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30 
31 #include "libavutil/common.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/imgutils.h"
35 #include "avfilter.h"
36 #include "formats.h"
37 #include "internal.h"
38 #include "video.h"
39 #include "bwdif.h"
40 
41 /*
42  * Filter coefficients coef_lf and coef_hf taken from BBC PH-2071 (Weston 3 Field Deinterlacer).
43  * Used when there is spatial and temporal interpolation.
44  * Filter coefficients coef_sp are used when there is spatial interpolation only.
45  * Adjusted for matching visual sharpness impression of spatial and temporal interpolation.
46  */
47 static const uint16_t coef_lf[2] = { 4309, 213 };
48 static const uint16_t coef_hf[3] = { 5570, 3801, 1016 };
49 static const uint16_t coef_sp[2] = { 5077, 981 };
50 
51 typedef struct ThreadData {
52  AVFrame *frame;
53  int plane;
54  int w, h;
55  int parity;
56  int tff;
57 } ThreadData;
58 
59 #define FILTER_INTRA() \
60  for (x = 0; x < w; x++) { \
61  interpol = (coef_sp[0] * (cur[mrefs] + cur[prefs]) - coef_sp[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
62  dst[0] = av_clip(interpol, 0, clip_max); \
63  \
64  dst++; \
65  cur++; \
66  }
67 
68 #define FILTER1() \
69  for (x = 0; x < w; x++) { \
70  int c = cur[mrefs]; \
71  int d = (prev2[0] + next2[0]) >> 1; \
72  int e = cur[prefs]; \
73  int temporal_diff0 = FFABS(prev2[0] - next2[0]); \
74  int temporal_diff1 =(FFABS(prev[mrefs] - c) + FFABS(prev[prefs] - e)) >> 1; \
75  int temporal_diff2 =(FFABS(next[mrefs] - c) + FFABS(next[prefs] - e)) >> 1; \
76  int diff = FFMAX3(temporal_diff0 >> 1, temporal_diff1, temporal_diff2); \
77  \
78  if (!diff) { \
79  dst[0] = d; \
80  } else {
81 
82 #define SPAT_CHECK() \
83  int b = ((prev2[mrefs2] + next2[mrefs2]) >> 1) - c; \
84  int f = ((prev2[prefs2] + next2[prefs2]) >> 1) - e; \
85  int dc = d - c; \
86  int de = d - e; \
87  int max = FFMAX3(de, dc, FFMIN(b, f)); \
88  int min = FFMIN3(de, dc, FFMAX(b, f)); \
89  diff = FFMAX3(diff, min, -max);
90 
91 #define FILTER_LINE() \
92  SPAT_CHECK() \
93  if (FFABS(c - e) > temporal_diff0) { \
94  interpol = (((coef_hf[0] * (prev2[0] + next2[0]) \
95  - coef_hf[1] * (prev2[mrefs2] + next2[mrefs2] + prev2[prefs2] + next2[prefs2]) \
96  + coef_hf[2] * (prev2[mrefs4] + next2[mrefs4] + prev2[prefs4] + next2[prefs4])) >> 2) \
97  + coef_lf[0] * (c + e) - coef_lf[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
98  } else { \
99  interpol = (coef_sp[0] * (c + e) - coef_sp[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
100  }
101 
102 #define FILTER_EDGE() \
103  if (spat) { \
104  SPAT_CHECK() \
105  } \
106  interpol = (c + e) >> 1;
107 
108 #define FILTER2() \
109  if (interpol > d + diff) \
110  interpol = d + diff; \
111  else if (interpol < d - diff) \
112  interpol = d - diff; \
113  \
114  dst[0] = av_clip(interpol, 0, clip_max); \
115  } \
116  \
117  dst++; \
118  cur++; \
119  prev++; \
120  next++; \
121  prev2++; \
122  next2++; \
123  }
124 
125 static void filter_intra(void *dst1, void *cur1, int w, int prefs, int mrefs,
126  int prefs3, int mrefs3, int parity, int clip_max)
127 {
128  uint8_t *dst = dst1;
129  uint8_t *cur = cur1;
130  int interpol, x;
131 
132  FILTER_INTRA()
133 }
134 
135 static void filter_line_c(void *dst1, void *prev1, void *cur1, void *next1,
136  int w, int prefs, int mrefs, int prefs2, int mrefs2,
137  int prefs3, int mrefs3, int prefs4, int mrefs4,
138  int parity, int clip_max)
139 {
140  uint8_t *dst = dst1;
141  uint8_t *prev = prev1;
142  uint8_t *cur = cur1;
143  uint8_t *next = next1;
144  uint8_t *prev2 = parity ? prev : cur ;
145  uint8_t *next2 = parity ? cur : next;
146  int interpol, x;
147 
148  FILTER1()
149  FILTER_LINE()
150  FILTER2()
151 }
152 
153 static void filter_edge(void *dst1, void *prev1, void *cur1, void *next1,
154  int w, int prefs, int mrefs, int prefs2, int mrefs2,
155  int parity, int clip_max, int spat)
156 {
157  uint8_t *dst = dst1;
158  uint8_t *prev = prev1;
159  uint8_t *cur = cur1;
160  uint8_t *next = next1;
161  uint8_t *prev2 = parity ? prev : cur ;
162  uint8_t *next2 = parity ? cur : next;
163  int interpol, x;
164 
165  FILTER1()
166  FILTER_EDGE()
167  FILTER2()
168 }
169 
170 static void filter_intra_16bit(void *dst1, void *cur1, int w, int prefs, int mrefs,
171  int prefs3, int mrefs3, int parity, int clip_max)
172 {
173  uint16_t *dst = dst1;
174  uint16_t *cur = cur1;
175  int interpol, x;
176 
177  FILTER_INTRA()
178 }
179 
180 static void filter_line_c_16bit(void *dst1, void *prev1, void *cur1, void *next1,
181  int w, int prefs, int mrefs, int prefs2, int mrefs2,
182  int prefs3, int mrefs3, int prefs4, int mrefs4,
183  int parity, int clip_max)
184 {
185  uint16_t *dst = dst1;
186  uint16_t *prev = prev1;
187  uint16_t *cur = cur1;
188  uint16_t *next = next1;
189  uint16_t *prev2 = parity ? prev : cur ;
190  uint16_t *next2 = parity ? cur : next;
191  int interpol, x;
192 
193  FILTER1()
194  FILTER_LINE()
195  FILTER2()
196 }
197 
198 static void filter_edge_16bit(void *dst1, void *prev1, void *cur1, void *next1,
199  int w, int prefs, int mrefs, int prefs2, int mrefs2,
200  int parity, int clip_max, int spat)
201 {
202  uint16_t *dst = dst1;
203  uint16_t *prev = prev1;
204  uint16_t *cur = cur1;
205  uint16_t *next = next1;
206  uint16_t *prev2 = parity ? prev : cur ;
207  uint16_t *next2 = parity ? cur : next;
208  int interpol, x;
209 
210  FILTER1()
211  FILTER_EDGE()
212  FILTER2()
213 }
214 
215 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
216 {
217  BWDIFContext *s = ctx->priv;
218  YADIFContext *yadif = &s->yadif;
219  ThreadData *td = arg;
220  int linesize = yadif->cur->linesize[td->plane];
221  int clip_max = (1 << (yadif->csp->comp[td->plane].depth)) - 1;
222  int df = (yadif->csp->comp[td->plane].depth + 7) / 8;
223  int refs = linesize / df;
224  int slice_start = (td->h * jobnr ) / nb_jobs;
225  int slice_end = (td->h * (jobnr+1)) / nb_jobs;
226  int y;
227 
228  for (y = slice_start; y < slice_end; y++) {
229  if ((y ^ td->parity) & 1) {
230  uint8_t *prev = &yadif->prev->data[td->plane][y * linesize];
231  uint8_t *cur = &yadif->cur ->data[td->plane][y * linesize];
232  uint8_t *next = &yadif->next->data[td->plane][y * linesize];
233  uint8_t *dst = &td->frame->data[td->plane][y * td->frame->linesize[td->plane]];
234  if (yadif->current_field == YADIF_FIELD_END) {
235  s->filter_intra(dst, cur, td->w, (y + df) < td->h ? refs : -refs,
236  y > (df - 1) ? -refs : refs,
237  (y + 3*df) < td->h ? 3 * refs : -refs,
238  y > (3*df - 1) ? -3 * refs : refs,
239  td->parity ^ td->tff, clip_max);
240  } else if ((y < 4) || ((y + 5) > td->h)) {
241  s->filter_edge(dst, prev, cur, next, td->w,
242  (y + df) < td->h ? refs : -refs,
243  y > (df - 1) ? -refs : refs,
244  refs << 1, -(refs << 1),
245  td->parity ^ td->tff, clip_max,
246  (y < 2) || ((y + 3) > td->h) ? 0 : 1);
247  } else {
248  s->filter_line(dst, prev, cur, next, td->w,
249  refs, -refs, refs << 1, -(refs << 1),
250  3 * refs, -3 * refs, refs << 2, -(refs << 2),
251  td->parity ^ td->tff, clip_max);
252  }
253  } else {
254  memcpy(&td->frame->data[td->plane][y * td->frame->linesize[td->plane]],
255  &yadif->cur->data[td->plane][y * linesize], td->w * df);
256  }
257  }
258  return 0;
259 }
260 
261 static void filter(AVFilterContext *ctx, AVFrame *dstpic,
262  int parity, int tff)
263 {
264  BWDIFContext *bwdif = ctx->priv;
265  YADIFContext *yadif = &bwdif->yadif;
266  ThreadData td = { .frame = dstpic, .parity = parity, .tff = tff };
267  int i;
268 
269  for (i = 0; i < yadif->csp->nb_components; i++) {
270  int w = dstpic->width;
271  int h = dstpic->height;
272 
273  if (i == 1 || i == 2) {
274  w = AV_CEIL_RSHIFT(w, yadif->csp->log2_chroma_w);
275  h = AV_CEIL_RSHIFT(h, yadif->csp->log2_chroma_h);
276  }
277 
278  td.w = w;
279  td.h = h;
280  td.plane = i;
281 
284  }
285  if (yadif->current_field == YADIF_FIELD_END) {
287  }
288 
289  emms_c();
290 }
291 
293 {
294  BWDIFContext *bwdif = ctx->priv;
295  YADIFContext *yadif = &bwdif->yadif;
296 
297  av_frame_free(&yadif->prev);
298  av_frame_free(&yadif->cur );
299  av_frame_free(&yadif->next);
300 }
301 
303 {
304  static const enum AVPixelFormat pix_fmts[] = {
323  };
324 
326 }
327 
329 {
330  AVFilterContext *ctx = link->src;
331  BWDIFContext *s = link->src->priv;
332  YADIFContext *yadif = &s->yadif;
333 
334  link->time_base = av_mul_q(ctx->inputs[0]->time_base, (AVRational){1, 2});
335  link->w = link->src->inputs[0]->w;
336  link->h = link->src->inputs[0]->h;
337 
338  if(yadif->mode&1)
339  link->frame_rate = av_mul_q(link->src->inputs[0]->frame_rate, (AVRational){2,1});
340 
341  if (link->w < 3 || link->h < 4) {
342  av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or 4 lines is not supported\n");
343  return AVERROR(EINVAL);
344  }
345 
346  yadif->csp = av_pix_fmt_desc_get(link->format);
347  yadif->filter = filter;
348  if (yadif->csp->comp[0].depth > 8) {
349  s->filter_intra = filter_intra_16bit;
350  s->filter_line = filter_line_c_16bit;
351  s->filter_edge = filter_edge_16bit;
352  } else {
353  s->filter_intra = filter_intra;
354  s->filter_line = filter_line_c;
355  s->filter_edge = filter_edge;
356  }
357 
358  if (ARCH_X86)
360 
361  return 0;
362 }
363 
364 
365 #define OFFSET(x) offsetof(YADIFContext, x)
366 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
367 
368 #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
369 
370 static const AVOption bwdif_options[] = {
371  { "mode", "specify the interlacing mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FIELD}, 0, 1, FLAGS, "mode"},
372  CONST("send_frame", "send one frame for each frame", YADIF_MODE_SEND_FRAME, "mode"),
373  CONST("send_field", "send one frame for each field", YADIF_MODE_SEND_FIELD, "mode"),
374 
375  { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1, FLAGS, "parity" },
376  CONST("tff", "assume top field first", YADIF_PARITY_TFF, "parity"),
377  CONST("bff", "assume bottom field first", YADIF_PARITY_BFF, "parity"),
378  CONST("auto", "auto detect parity", YADIF_PARITY_AUTO, "parity"),
379 
380  { "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
381  CONST("all", "deinterlace all frames", YADIF_DEINT_ALL, "deint"),
382  CONST("interlaced", "only deinterlace frames marked as interlaced", YADIF_DEINT_INTERLACED, "deint"),
383 
384  { NULL }
385 };
386 
387 AVFILTER_DEFINE_CLASS(bwdif);
388 
390  {
391  .name = "default",
392  .type = AVMEDIA_TYPE_VIDEO,
393  .filter_frame = ff_yadif_filter_frame,
394  },
395 };
396 
398  {
399  .name = "default",
400  .type = AVMEDIA_TYPE_VIDEO,
401  .request_frame = ff_yadif_request_frame,
402  .config_props = config_props,
403  },
404 };
405 
407  .name = "bwdif",
408  .description = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
409  .priv_size = sizeof(BWDIFContext),
410  .priv_class = &bwdif_class,
411  .uninit = uninit,
416 };
FILTER2
#define FILTER2()
Definition: vf_bwdif.c:108
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:432
YADIF_MODE_SEND_FIELD
@ YADIF_MODE_SEND_FIELD
send 1 frame for each field
Definition: yadif.h:28
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:411
interpol
static int interpol(MBContext *s, uint32_t *color, int x, int y, int linesize)
Definition: vsrc_mandelbrot.c:192
td
#define td
Definition: regdef.h:70
OFFSET
#define OFFSET(x)
Definition: vf_bwdif.c:365
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
df
#define df(A, B)
Definition: vf_xbr.c:89
config_props
static int config_props(AVFilterLink *link)
Definition: vf_bwdif.c:328
FILTER_LINE
#define FILTER_LINE()
Definition: vf_bwdif.c:91
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
YADIFContext::csp
const AVPixFmtDescriptor * csp
Definition: yadif.h:75
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
YADIFContext::mode
int mode
YADIFMode.
Definition: yadif.h:53
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:424
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
AVFrame::width
int width
Definition: frame.h:361
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:431
w
uint8_t w
Definition: llviddspenc.c:38
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:426
AVOption
AVOption.
Definition: opt.h:247
ThreadData::tff
int tff
Definition: vf_bwdif.c:56
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
ThreadData::frame
AVFrame * frame
Definition: dsddec.c:68
ThreadData::w
int w
Definition: vf_blend.c:59
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:153
video.h
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:427
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
YADIF_MODE_SEND_FRAME
@ YADIF_MODE_SEND_FRAME
send 1 frame for each frame
Definition: yadif.h:27
formats.h
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:423
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:407
FILTER_INTRA
#define FILTER_INTRA()
Definition: vf_bwdif.c:59
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:405
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:433
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:387
YADIF_PARITY_AUTO
@ YADIF_PARITY_AUTO
auto detection
Definition: yadif.h:36
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:373
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
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:248
filter_edge
static void filter_edge(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int prefs2, int mrefs2, int parity, int clip_max, int spat)
Definition: vf_bwdif.c:153
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:401
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:79
ThreadData::plane
int plane
Definition: vf_blend.c:58
s
#define s(width, name)
Definition: cbs_vp9.c:257
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:402
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2041
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:703
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:386
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:400
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
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
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_bwdif.c:302
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:152
ThreadData::h
int h
Definition: vf_blend.c:59
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:80
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:408
NULL
#define NULL
Definition: coverity.c:32
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
filter_line_c
static void filter_line_c(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int prefs2, int mrefs2, int prefs3, int mrefs3, int prefs4, int mrefs4, int parity, int clip_max)
Definition: vf_bwdif.c:135
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:78
ff_vf_bwdif
const AVFilter ff_vf_bwdif
Definition: vf_bwdif.c:406
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(bwdif)
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
ff_bwdif_init_x86
void ff_bwdif_init_x86(BWDIFContext *bwdif)
Definition: vf_bwdif_init.c:53
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:404
FILTER1
#define FILTER1()
Definition: vf_bwdif.c:68
filter_line_c_16bit
static void filter_line_c_16bit(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int prefs2, int mrefs2, int prefs3, int mrefs3, int prefs4, int mrefs4, int parity, int clip_max)
Definition: vf_bwdif.c:180
filter
static void filter(AVFilterContext *ctx, AVFrame *dstpic, int parity, int tff)
Definition: vf_bwdif.c:261
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_bwdif.c:215
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
ThreadData::parity
int parity
Definition: vf_bwdif.c:55
FLAGS
#define FLAGS
Definition: vf_bwdif.c:366
coef_sp
static const uint16_t coef_sp[2]
Definition: vf_bwdif.c:49
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
YADIFContext::filter
void(* filter)(AVFilterContext *ctx, AVFrame *dstpic, int parity, int tff)
Definition: yadif.h:64
parity
mcdeint parity
Definition: vf_mcdeint.c:274
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:376
YADIFContext::prev
AVFrame * prev
Definition: yadif.h:61
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:428
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_bwdif.c:292
internal.h
i
int i
Definition: input.c:406
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:406
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:804
ThreadData
Used for passing data between threads.
Definition: dsddec.c:67
YADIFContext
Definition: yadif.h:50
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
avfilter_vf_bwdif_outputs
static const AVFilterPad avfilter_vf_bwdif_outputs[]
Definition: vf_bwdif.c:397
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:100
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
BWDIFContext::yadif
YADIFContext yadif
Definition: bwdif.h:27
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:388
bwdif_options
static const AVOption bwdif_options[]
Definition: vf_bwdif.c:370
FILTER_EDGE
#define FILTER_EDGE()
Definition: vf_bwdif.c:102
AVFilter
Filter definition.
Definition: avfilter.h:149
YADIF_DEINT_ALL
@ YADIF_DEINT_ALL
deinterlace all frames
Definition: yadif.h:40
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:425
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:393
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:398
AVFrame::height
int height
Definition: frame.h:361
YADIFContext::next
AVFrame * next
Definition: yadif.h:60
YADIF_FIELD_END
@ YADIF_FIELD_END
The first or last field in a sequence.
Definition: yadif.h:46
BWDIFContext
Definition: bwdif.h:26
mode
mode
Definition: ebur128.h:83
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ff_yadif_request_frame
int ff_yadif_request_frame(AVFilterLink *link)
Definition: yadif_common.c:159
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
filter_intra
static void filter_intra(void *dst1, void *cur1, int w, int prefs, int mrefs, int prefs3, int mrefs3, int parity, int clip_max)
Definition: vf_bwdif.c:125
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
filter_edge_16bit
static void filter_edge_16bit(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int prefs2, int mrefs2, int parity, int clip_max, int spat)
Definition: vf_bwdif.c:198
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
CONST
#define CONST(name, help, val, unit)
Definition: vf_bwdif.c:368
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:346
YADIF_DEINT_INTERLACED
@ YADIF_DEINT_INTERLACED
only deinterlace frames marked as interlaced
Definition: yadif.h:41
YADIF_FIELD_NORMAL
@ YADIF_FIELD_NORMAL
A normal field in the middle of a sequence.
Definition: yadif.h:47
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:121
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
YADIF_PARITY_TFF
@ YADIF_PARITY_TFF
top field first
Definition: yadif.h:34
YADIFContext::current_field
int current_field
YADIFCurrentField.
Definition: yadif.h:86
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:153
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
filter_intra_16bit
static void filter_intra_16bit(void *dst1, void *cur1, int w, int prefs, int mrefs, int prefs3, int mrefs3, int parity, int clip_max)
Definition: vf_bwdif.c:170
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:138
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
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:28
coef_hf
static const uint16_t coef_hf[3]
Definition: vf_bwdif.c:48
h
h
Definition: vp9dsp_template.c:2038
YADIFContext::cur
AVFrame * cur
Definition: yadif.h:59
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:399
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:143
avfilter_vf_bwdif_inputs
static const AVFilterPad avfilter_vf_bwdif_inputs[]
Definition: vf_bwdif.c:389
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
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
ff_yadif_filter_frame
int ff_yadif_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: yadif_common.c:92
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:397
YADIF_PARITY_BFF
@ YADIF_PARITY_BFF
bottom field first
Definition: yadif.h:35
coef_lf
static const uint16_t coef_lf[2]
Definition: vf_bwdif.c:47
bwdif.h