FFmpeg
vf_yadif.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2006-2011 Michael Niedermayer <michaelni@gmx.at>
3  * 2010 James Darnley <james.darnley@gmail.com>
4 
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
23 #include "libavutil/cpu.h"
24 #include "libavutil/common.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/imgutils.h"
27 #include "avfilter.h"
28 #include "formats.h"
29 #include "internal.h"
30 #include "video.h"
31 #include "yadif.h"
32 
33 typedef struct ThreadData {
34  AVFrame *frame;
35  int plane;
36  int w, h;
37  int parity;
38  int tff;
39 } ThreadData;
40 
41 #define CHECK(j)\
42  { int score = FFABS(cur[mrefs - 1 + (j)] - cur[prefs - 1 - (j)])\
43  + FFABS(cur[mrefs +(j)] - cur[prefs -(j)])\
44  + FFABS(cur[mrefs + 1 + (j)] - cur[prefs + 1 - (j)]);\
45  if (score < spatial_score) {\
46  spatial_score= score;\
47  spatial_pred= (cur[mrefs +(j)] + cur[prefs -(j)])>>1;\
48 
49 /* The is_not_edge argument here controls when the code will enter a branch
50  * which reads up to and including x-3 and x+3. */
51 
52 #define FILTER(start, end, is_not_edge) \
53  for (x = start; x < end; x++) { \
54  int c = cur[mrefs]; \
55  int d = (prev2[0] + next2[0])>>1; \
56  int e = cur[prefs]; \
57  int temporal_diff0 = FFABS(prev2[0] - next2[0]); \
58  int temporal_diff1 =(FFABS(prev[mrefs] - c) + FFABS(prev[prefs] - e) )>>1; \
59  int temporal_diff2 =(FFABS(next[mrefs] - c) + FFABS(next[prefs] - e) )>>1; \
60  int diff = FFMAX3(temporal_diff0 >> 1, temporal_diff1, temporal_diff2); \
61  int spatial_pred = (c+e) >> 1; \
62  \
63  if (is_not_edge) {\
64  int spatial_score = FFABS(cur[mrefs - 1] - cur[prefs - 1]) + FFABS(c-e) \
65  + FFABS(cur[mrefs + 1] - cur[prefs + 1]) - 1; \
66  CHECK(-1) CHECK(-2) }} }} \
67  CHECK( 1) CHECK( 2) }} }} \
68  }\
69  \
70  if (!(mode&2)) { \
71  int b = (prev2[2 * mrefs] + next2[2 * mrefs])>>1; \
72  int f = (prev2[2 * prefs] + next2[2 * prefs])>>1; \
73  int max = FFMAX3(d - e, d - c, FFMIN(b - c, f - e)); \
74  int min = FFMIN3(d - e, d - c, FFMAX(b - c, f - e)); \
75  \
76  diff = FFMAX3(diff, min, -max); \
77  } \
78  \
79  if (spatial_pred > d + diff) \
80  spatial_pred = d + diff; \
81  else if (spatial_pred < d - diff) \
82  spatial_pred = d - diff; \
83  \
84  dst[0] = spatial_pred; \
85  \
86  dst++; \
87  cur++; \
88  prev++; \
89  next++; \
90  prev2++; \
91  next2++; \
92  }
93 
94 static void filter_line_c(void *dst1,
95  void *prev1, void *cur1, void *next1,
96  int w, int prefs, int mrefs, int parity, int mode)
97 {
98  uint8_t *dst = dst1;
99  uint8_t *prev = prev1;
100  uint8_t *cur = cur1;
101  uint8_t *next = next1;
102  int x;
103  uint8_t *prev2 = parity ? prev : cur ;
104  uint8_t *next2 = parity ? cur : next;
105 
106  /* The function is called with the pointers already pointing to data[3] and
107  * with 6 subtracted from the width. This allows the FILTER macro to be
108  * called so that it processes all the pixels normally. A constant value of
109  * true for is_not_edge lets the compiler ignore the if statement. */
110  FILTER(0, w, 1)
111 }
112 
113 #define MAX_ALIGN 8
114 static void filter_edges(void *dst1, void *prev1, void *cur1, void *next1,
115  int w, int prefs, int mrefs, int parity, int mode)
116 {
117  uint8_t *dst = dst1;
118  uint8_t *prev = prev1;
119  uint8_t *cur = cur1;
120  uint8_t *next = next1;
121  int x;
122  uint8_t *prev2 = parity ? prev : cur ;
123  uint8_t *next2 = parity ? cur : next;
124 
125  const int edge = MAX_ALIGN - 1;
126  int offset = FFMAX(w - edge, 3);
127 
128  /* Only edge pixels need to be processed here. A constant value of false
129  * for is_not_edge should let the compiler ignore the whole branch. */
130  FILTER(0, FFMIN(3, w), 0)
131 
132  dst = (uint8_t*)dst1 + offset;
133  prev = (uint8_t*)prev1 + offset;
134  cur = (uint8_t*)cur1 + offset;
135  next = (uint8_t*)next1 + offset;
136  prev2 = (uint8_t*)(parity ? prev : cur);
137  next2 = (uint8_t*)(parity ? cur : next);
138 
139  FILTER(offset, w - 3, 1)
140  offset = FFMAX(offset, w - 3);
141  FILTER(offset, w, 0)
142 }
143 
144 
145 static void filter_line_c_16bit(void *dst1,
146  void *prev1, void *cur1, void *next1,
147  int w, int prefs, int mrefs, int parity,
148  int mode)
149 {
150  uint16_t *dst = dst1;
151  uint16_t *prev = prev1;
152  uint16_t *cur = cur1;
153  uint16_t *next = next1;
154  int x;
155  uint16_t *prev2 = parity ? prev : cur ;
156  uint16_t *next2 = parity ? cur : next;
157  mrefs /= 2;
158  prefs /= 2;
159 
160  FILTER(0, w, 1)
161 }
162 
163 static void filter_edges_16bit(void *dst1, void *prev1, void *cur1, void *next1,
164  int w, int prefs, int mrefs, int parity, int mode)
165 {
166  uint16_t *dst = dst1;
167  uint16_t *prev = prev1;
168  uint16_t *cur = cur1;
169  uint16_t *next = next1;
170  int x;
171  uint16_t *prev2 = parity ? prev : cur ;
172  uint16_t *next2 = parity ? cur : next;
173 
174  const int edge = MAX_ALIGN / 2 - 1;
175  int offset = FFMAX(w - edge, 3);
176 
177  mrefs /= 2;
178  prefs /= 2;
179 
180  FILTER(0, FFMIN(3, w), 0)
181 
182  dst = (uint16_t*)dst1 + offset;
183  prev = (uint16_t*)prev1 + offset;
184  cur = (uint16_t*)cur1 + offset;
185  next = (uint16_t*)next1 + offset;
186  prev2 = (uint16_t*)(parity ? prev : cur);
187  next2 = (uint16_t*)(parity ? cur : next);
188 
189  FILTER(offset, w - 3, 1)
190  offset = FFMAX(offset, w - 3);
191  FILTER(offset, w, 0)
192 }
193 
194 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
195 {
196  YADIFContext *s = ctx->priv;
197  ThreadData *td = arg;
198  int refs = s->cur->linesize[td->plane];
199  int df = (s->csp->comp[td->plane].depth + 7) / 8;
200  int pix_3 = 3 * df;
201  int slice_start = (td->h * jobnr ) / nb_jobs;
202  int slice_end = (td->h * (jobnr+1)) / nb_jobs;
203  int y;
204  int edge = 3 + MAX_ALIGN / df - 1;
205 
206  /* filtering reads 3 pixels to the left/right; to avoid invalid reads,
207  * we need to call the c variant which avoids this for border pixels
208  */
209  for (y = slice_start; y < slice_end; y++) {
210  if ((y ^ td->parity) & 1) {
211  uint8_t *prev = &s->prev->data[td->plane][y * refs];
212  uint8_t *cur = &s->cur ->data[td->plane][y * refs];
213  uint8_t *next = &s->next->data[td->plane][y * refs];
214  uint8_t *dst = &td->frame->data[td->plane][y * td->frame->linesize[td->plane]];
215  int mode = y == 1 || y + 2 == td->h ? 2 : s->mode;
216  s->filter_line(dst + pix_3, prev + pix_3, cur + pix_3,
217  next + pix_3, td->w - edge,
218  y + 1 < td->h ? refs : -refs,
219  y ? -refs : refs,
220  td->parity ^ td->tff, mode);
221  s->filter_edges(dst, prev, cur, next, td->w,
222  y + 1 < td->h ? refs : -refs,
223  y ? -refs : refs,
224  td->parity ^ td->tff, mode);
225  } else {
226  memcpy(&td->frame->data[td->plane][y * td->frame->linesize[td->plane]],
227  &s->cur->data[td->plane][y * refs], td->w * df);
228  }
229  }
230  return 0;
231 }
232 
233 static void filter(AVFilterContext *ctx, AVFrame *dstpic,
234  int parity, int tff)
235 {
236  YADIFContext *yadif = ctx->priv;
237  ThreadData td = { .frame = dstpic, .parity = parity, .tff = tff };
238  int i;
239 
240  for (i = 0; i < yadif->csp->nb_components; i++) {
241  int w = dstpic->width;
242  int h = dstpic->height;
243 
244  if (i == 1 || i == 2) {
245  w = AV_CEIL_RSHIFT(w, yadif->csp->log2_chroma_w);
246  h = AV_CEIL_RSHIFT(h, yadif->csp->log2_chroma_h);
247  }
248 
249 
250  td.w = w;
251  td.h = h;
252  td.plane = i;
253 
255  }
256 
257  emms_c();
258 }
259 
261 {
262  YADIFContext *yadif = ctx->priv;
263 
264  av_frame_free(&yadif->prev);
265  av_frame_free(&yadif->cur );
266  av_frame_free(&yadif->next);
267 }
268 
270 {
271  static const enum AVPixelFormat pix_fmts[] = {
310  };
311 
313  if (!fmts_list)
314  return AVERROR(ENOMEM);
315  return ff_set_common_formats(ctx, fmts_list);
316 }
317 
319 {
320  AVFilterContext *ctx = link->src;
321  YADIFContext *s = ctx->priv;
322 
323  link->time_base.num = ctx->inputs[0]->time_base.num;
324  link->time_base.den = ctx->inputs[0]->time_base.den * 2;
325  link->w = ctx->inputs[0]->w;
326  link->h = ctx->inputs[0]->h;
327 
328  if(s->mode & 1)
329  link->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
330  (AVRational){2, 1});
331 
332  if (link->w < 3 || link->h < 3) {
333  av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or lines is not supported\n");
334  return AVERROR(EINVAL);
335  }
336 
337  s->csp = av_pix_fmt_desc_get(link->format);
338  s->filter = filter;
339  if (s->csp->comp[0].depth > 8) {
340  s->filter_line = filter_line_c_16bit;
341  s->filter_edges = filter_edges_16bit;
342  } else {
343  s->filter_line = filter_line_c;
344  s->filter_edges = filter_edges;
345  }
346 
347  if (ARCH_X86)
349 
350  return 0;
351 }
352 
353 
354 static const AVClass yadif_class = {
355  .class_name = "yadif",
356  .item_name = av_default_item_name,
357  .option = ff_yadif_options,
358  .version = LIBAVUTIL_VERSION_INT,
359  .category = AV_CLASS_CATEGORY_FILTER,
360 };
361 
363  {
364  .name = "default",
365  .type = AVMEDIA_TYPE_VIDEO,
366  .filter_frame = ff_yadif_filter_frame,
367  },
368  { NULL }
369 };
370 
372  {
373  .name = "default",
374  .type = AVMEDIA_TYPE_VIDEO,
375  .request_frame = ff_yadif_request_frame,
376  .config_props = config_props,
377  },
378  { NULL }
379 };
380 
382  .name = "yadif",
383  .description = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
384  .priv_size = sizeof(YADIFContext),
385  .priv_class = &yadif_class,
386  .uninit = uninit,
391 };
ff_yadif_init_x86
av_cold void ff_yadif_init_x86(YADIFContext *yadif)
Definition: vf_yadif_init.c:60
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
df
#define df(A, B)
Definition: vf_xbr.c:90
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
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 parity, int mode)
Definition: vf_yadif.c:145
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:202
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
pixdesc.h
AVFrame::width
int width
Definition: frame.h:353
w
uint8_t w
Definition: llviddspenc.c:38
ThreadData::tff
int tff
Definition: vf_bwdif.c:57
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_yadif.c:269
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
ThreadData::frame
AVFrame * frame
Definition: vf_bwdif.c:53
ThreadData::w
int w
Definition: vf_blend.c:58
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:148
video.h
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1795
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:405
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:84
avfilter_vf_yadif_inputs
static const AVFilterPad avfilter_vf_yadif_inputs[]
Definition: vf_yadif.c:362
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
ff_set_common_formats
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:568
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_yadif.c:194
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:57
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:400
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
MAX_ALIGN
#define MAX_ALIGN
Definition: vf_yadif.c:113
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_yadif.c:260
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2026
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
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:92
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
ThreadData::h
int h
Definition: vf_blend.c:58
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:66
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:406
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
filter_line_c
static void filter_line_c(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int parity, int mode)
Definition: vf_yadif.c:94
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
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
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
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:402
AV_CLASS_CATEGORY_FILTER
@ AV_CLASS_CATEGORY_FILTER
Definition: log.h:37
ff_yadif_options
const AVOption ff_yadif_options[]
Definition: yadif_common.c:198
yadif.h
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:188
ThreadData::parity
int parity
Definition: vf_bwdif.c:56
cpu.h
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
avfilter_vf_yadif_outputs
static const AVFilterPad avfilter_vf_yadif_outputs[]
Definition: vf_yadif.c:371
parity
mcdeint parity
Definition: vf_mcdeint.c:274
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:368
filter_edges
static void filter_edges(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int parity, int mode)
Definition: vf_yadif.c:114
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
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:177
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
internal.h
FILTER
#define FILTER(start, end, is_not_edge)
Definition: vf_yadif.c:52
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
filter_edges_16bit
static void filter_edges_16bit(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int parity, int mode)
Definition: vf_yadif.c:163
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:802
ThreadData
Used for passing data between threads.
Definition: af_adeclick.c:487
YADIFContext
Definition: yadif.h:50
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
uint8_t
uint8_t
Definition: audio_convert.c:194
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
AVFilter
Filter definition.
Definition: avfilter.h:144
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:396
AVFrame::height
int height
Definition: frame.h:353
YADIFContext::next
AVFrame * next
Definition: yadif.h:60
filter
static void filter(AVFilterContext *ctx, AVFrame *dstpic, int parity, int tff)
Definition: vf_yadif.c:233
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
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:71
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
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:116
config_props
static int config_props(AVFilterLink *link)
Definition: vf_yadif.c:318
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
ff_vf_yadif
AVFilter ff_vf_yadif
Definition: vf_yadif.c:381
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
yadif_class
static const AVClass yadif_class
Definition: vf_yadif.c:354
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:133
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
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
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:397
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
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:176
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:395