FFmpeg
vf_tinterlace.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 Thomas Mundt <tmundt75@gmail.com>
3  * Copyright (c) 2011 Stefano Sabatini
4  * Copyright (c) 2010 Baptiste Coudurier
5  * Copyright (c) 2003 Michael Zucchi <notzed@ximian.com>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (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
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with FFmpeg if not, write to the Free Software Foundation, Inc.,
21  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22  */
23 
24 /**
25  * @file
26  * temporal field interlace filter, ported from MPlayer/libmpcodecs
27  */
28 
29 #include "libavutil/opt.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/avassert.h"
32 #include "avfilter.h"
33 #include "internal.h"
34 #include "tinterlace.h"
35 #include "video.h"
36 
37 #define OFFSET(x) offsetof(TInterlaceContext, x)
38 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
39 
40 static const AVOption tinterlace_options[] = {
41  {"mode", "select interlace mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_MERGE}, 0, MODE_NB-1, FLAGS, .unit = "mode"},
42  {"merge", "merge fields", 0, AV_OPT_TYPE_CONST, {.i64=MODE_MERGE}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
43  {"drop_even", "drop even fields", 0, AV_OPT_TYPE_CONST, {.i64=MODE_DROP_EVEN}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
44  {"drop_odd", "drop odd fields", 0, AV_OPT_TYPE_CONST, {.i64=MODE_DROP_ODD}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
45  {"pad", "pad alternate lines with black", 0, AV_OPT_TYPE_CONST, {.i64=MODE_PAD}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
46  {"interleave_top", "interleave top and bottom fields", 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE_TOP}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
47  {"interleave_bottom", "interleave bottom and top fields", 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLEAVE_BOTTOM}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
48  {"interlacex2", "interlace fields from two consecutive frames", 0, AV_OPT_TYPE_CONST, {.i64=MODE_INTERLACEX2}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
49  {"mergex2", "merge fields keeping same frame rate", 0, AV_OPT_TYPE_CONST, {.i64=MODE_MERGEX2}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
50 
51  {"flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, 0, .unit = "flags" },
52  {"low_pass_filter", "enable vertical low-pass filter", 0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_VLPF}, INT_MIN, INT_MAX, FLAGS, .unit = "flags" },
53  {"vlpf", "enable vertical low-pass filter", 0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_VLPF}, INT_MIN, INT_MAX, FLAGS, .unit = "flags" },
54  {"complex_filter", "enable complex vertical low-pass filter", 0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_CVLPF},INT_MIN, INT_MAX, FLAGS, .unit = "flags" },
55  {"cvlpf", "enable complex vertical low-pass filter", 0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_CVLPF},INT_MIN, INT_MAX, FLAGS, .unit = "flags" },
56  {"exact_tb", "force a timebase which can represent timestamps exactly", 0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_EXACT_TB}, INT_MIN, INT_MAX, FLAGS, .unit = "flags" },
57  {"bypass_il", "bypass already interlaced frames", 0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_BYPASS_IL}, INT_MIN, INT_MAX, FLAGS, .unit = "flags" },
58 
59  {NULL}
60 };
61 
62 AVFILTER_DEFINE_CLASS(tinterlace);
63 
64 static const AVOption interlace_options[] = {
65  { "scan", "scanning mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = MODE_TFF}, 0, 1, FLAGS, .unit = "mode"},
66  { "tff", "top field first", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_TFF}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
67  { "bff", "bottom field first", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_BFF}, INT_MIN, INT_MAX, FLAGS, .unit = "mode"},
68  { "lowpass", "set vertical low-pass filter", OFFSET(lowpass), AV_OPT_TYPE_INT, {.i64 = VLPF_LIN}, 0, 2, FLAGS, .unit = "lowpass" },
69  { "off", "disable vertical low-pass filter", 0, AV_OPT_TYPE_CONST, {.i64 = VLPF_OFF}, INT_MIN, INT_MAX, FLAGS, .unit = "lowpass" },
70  { "linear", "linear vertical low-pass filter", 0, AV_OPT_TYPE_CONST, {.i64 = VLPF_LIN}, INT_MIN, INT_MAX, FLAGS, .unit = "lowpass" },
71  { "complex", "complex vertical low-pass filter", 0, AV_OPT_TYPE_CONST, {.i64 = VLPF_CMP}, INT_MIN, INT_MAX, FLAGS, .unit = "lowpass" },
72 
73  { NULL }
74 };
75 
76 AVFILTER_DEFINE_CLASS(interlace);
77 
78 #define FULL_SCALE_YUVJ_FORMATS \
79  AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P
80 
81 static const enum AVPixelFormat full_scale_yuvj_pix_fmts[] = {
82  FULL_SCALE_YUVJ_FORMATS, AV_PIX_FMT_NONE
83 };
84 
85 static const AVRational standard_tbs[] = {
86  {1, 25},
87  {1, 30},
88  {1001, 30000},
89 };
90 
91 static const enum AVPixelFormat pix_fmts[] = {
92  AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
93  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
94  AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
95  AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUV422P10LE,
96  AV_PIX_FMT_YUV440P10LE, AV_PIX_FMT_YUV444P10LE,
97  AV_PIX_FMT_YUV420P12LE, AV_PIX_FMT_YUV422P12LE,
98  AV_PIX_FMT_YUV440P12LE, AV_PIX_FMT_YUV444P12LE,
99  AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
100  AV_PIX_FMT_YUVA420P10LE, AV_PIX_FMT_YUVA422P10LE, AV_PIX_FMT_YUVA444P10LE,
101  AV_PIX_FMT_GRAY8, FULL_SCALE_YUVJ_FORMATS,
102  AV_PIX_FMT_NONE
103 };
104 
105 static void lowpass_line_c(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp,
106  ptrdiff_t mref, ptrdiff_t pref, int clip_max)
107 {
108  const uint8_t *srcp_above = srcp + mref;
109  const uint8_t *srcp_below = srcp + pref;
110  int i;
111  for (i = 0; i < width; i++) {
112  // this calculation is an integer representation of
113  // '0.5 * current + 0.25 * above + 0.25 * below'
114  // '1 +' is for rounding.
115  dstp[i] = (1 + srcp[i] + srcp[i] + srcp_above[i] + srcp_below[i]) >> 2;
116  }
117 }
118 
119 static void lowpass_line_c_16(uint8_t *dst8, ptrdiff_t width, const uint8_t *src8,
120  ptrdiff_t mref, ptrdiff_t pref, int clip_max)
121 {
122  uint16_t *dstp = (uint16_t *)dst8;
123  const uint16_t *srcp = (const uint16_t *)src8;
124  const uint16_t *srcp_above = srcp + mref / 2;
125  const uint16_t *srcp_below = srcp + pref / 2;
126  int i, src_x;
127  for (i = 0; i < width; i++) {
128  // this calculation is an integer representation of
129  // '0.5 * current + 0.25 * above + 0.25 * below'
130  // '1 +' is for rounding.
131  src_x = av_le2ne16(srcp[i]) << 1;
132  dstp[i] = av_le2ne16((1 + src_x + av_le2ne16(srcp_above[i])
133  + av_le2ne16(srcp_below[i])) >> 2);
134  }
135 }
136 
137 static void lowpass_line_complex_c(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp,
138  ptrdiff_t mref, ptrdiff_t pref, int clip_max)
139 {
140  const uint8_t *srcp_above = srcp + mref;
141  const uint8_t *srcp_below = srcp + pref;
142  const uint8_t *srcp_above2 = srcp + mref * 2;
143  const uint8_t *srcp_below2 = srcp + pref * 2;
144  int i, src_x, src_ab;
145  for (i = 0; i < width; i++) {
146  // this calculation is an integer representation of
147  // '0.75 * current + 0.25 * above + 0.25 * below - 0.125 * above2 - 0.125 * below2'
148  // '4 +' is for rounding.
149  src_x = srcp[i] << 1;
150  src_ab = srcp_above[i] + srcp_below[i];
151  dstp[i] = av_clip_uint8((4 + ((srcp[i] + src_x + src_ab) << 1)
152  - srcp_above2[i] - srcp_below2[i]) >> 3);
153  // Prevent over-sharpening:
154  // dst must not exceed src when the average of above and below
155  // is less than src. And the other way around.
156  if (src_ab > src_x) {
157  if (dstp[i] < srcp[i])
158  dstp[i] = srcp[i];
159  } else if (dstp[i] > srcp[i])
160  dstp[i] = srcp[i];
161  }
162 }
163 
164 static void lowpass_line_complex_c_16(uint8_t *dst8, ptrdiff_t width, const uint8_t *src8,
165  ptrdiff_t mref, ptrdiff_t pref, int clip_max)
166 {
167  uint16_t *dstp = (uint16_t *)dst8;
168  const uint16_t *srcp = (const uint16_t *)src8;
169  const uint16_t *srcp_above = srcp + mref / 2;
170  const uint16_t *srcp_below = srcp + pref / 2;
171  const uint16_t *srcp_above2 = srcp + mref;
172  const uint16_t *srcp_below2 = srcp + pref;
173  int i, dst_le, src_le, src_x, src_ab;
174  for (i = 0; i < width; i++) {
175  // this calculation is an integer representation of
176  // '0.75 * current + 0.25 * above + 0.25 * below - 0.125 * above2 - 0.125 * below2'
177  // '4 +' is for rounding.
178  src_le = av_le2ne16(srcp[i]);
179  src_x = src_le << 1;
180  src_ab = av_le2ne16(srcp_above[i]) + av_le2ne16(srcp_below[i]);
181  dst_le = av_clip((4 + ((src_le + src_x + src_ab) << 1)
182  - av_le2ne16(srcp_above2[i])
183  - av_le2ne16(srcp_below2[i])) >> 3, 0, clip_max);
184  // Prevent over-sharpening:
185  // dst must not exceed src when the average of above and below
186  // is less than src. And the other way around.
187  if (src_ab > src_x) {
188  if (dst_le < src_le)
189  dstp[i] = av_le2ne16(src_le);
190  else
191  dstp[i] = av_le2ne16(dst_le);
192  } else if (dst_le > src_le) {
193  dstp[i] = av_le2ne16(src_le);
194  } else
195  dstp[i] = av_le2ne16(dst_le);
196  }
197 }
198 
199 static av_cold void uninit(AVFilterContext *ctx)
200 {
201  TInterlaceContext *tinterlace = ctx->priv;
202 
203  av_frame_free(&tinterlace->cur );
204  av_frame_free(&tinterlace->next);
205  av_freep(&tinterlace->black_data[0][0]);
206  av_freep(&tinterlace->black_data[1][0]);
207  ff_ccfifo_uninit(&tinterlace->cc_fifo);
208 }
209 
210 static int config_out_props(AVFilterLink *outlink)
211 {
212  AVFilterContext *ctx = outlink->src;
213  AVFilterLink *inlink = outlink->src->inputs[0];
214  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
215  TInterlaceContext *tinterlace = ctx->priv;
216  int ret, i;
217 
218  tinterlace->vsub = desc->log2_chroma_h;
219  outlink->w = inlink->w;
220  outlink->h = tinterlace->mode == MODE_MERGE || tinterlace->mode == MODE_PAD || tinterlace->mode == MODE_MERGEX2?
221  inlink->h*2 : inlink->h;
222  if (tinterlace->mode == MODE_MERGE || tinterlace->mode == MODE_PAD || tinterlace->mode == MODE_MERGEX2)
223  outlink->sample_aspect_ratio = av_mul_q(inlink->sample_aspect_ratio,
224  av_make_q(2, 1));
225 
226  if (tinterlace->mode == MODE_PAD) {
227  uint8_t black[4] = { 0, 0, 0, 16 };
228  ff_draw_init2(&tinterlace->draw, outlink->format, outlink->colorspace, outlink->color_range, 0);
229  ff_draw_color(&tinterlace->draw, &tinterlace->color, black);
230  /* limited range */
231  if (!ff_fmt_is_in(outlink->format, full_scale_yuvj_pix_fmts)) {
232  ret = av_image_alloc(tinterlace->black_data[0], tinterlace->black_linesize,
233  outlink->w, outlink->h, outlink->format, 16);
234  if (ret < 0)
235  return ret;
236  ff_fill_rectangle(&tinterlace->draw, &tinterlace->color, tinterlace->black_data[0],
237  tinterlace->black_linesize, 0, 0, outlink->w, outlink->h);
238  }
239  /* full range */
240  tinterlace->color.comp[0].u8[0] = 0;
241  ret = av_image_alloc(tinterlace->black_data[1], tinterlace->black_linesize,
242  outlink->w, outlink->h, outlink->format, 16);
243  if (ret < 0)
244  return ret;
245  ff_fill_rectangle(&tinterlace->draw, &tinterlace->color, tinterlace->black_data[1],
246  tinterlace->black_linesize, 0, 0, outlink->w, outlink->h);
247  }
248  if (tinterlace->flags & (TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF)
249  && !(tinterlace->mode == MODE_INTERLEAVE_TOP
250  || tinterlace->mode == MODE_INTERLEAVE_BOTTOM)) {
251  av_log(ctx, AV_LOG_WARNING, "low_pass_filter flags ignored with mode %d\n",
252  tinterlace->mode);
253  tinterlace->flags &= ~(TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF);
254  }
255  tinterlace->preout_time_base = inlink->time_base;
256  if (tinterlace->mode == MODE_INTERLACEX2) {
257  tinterlace->preout_time_base.den *= 2;
258  outlink->frame_rate = av_mul_q(inlink->frame_rate, (AVRational){2,1});
259  outlink->time_base = av_mul_q(inlink->time_base , (AVRational){1,2});
260  } else if (tinterlace->mode == MODE_MERGEX2) {
261  outlink->frame_rate = inlink->frame_rate;
262  outlink->time_base = inlink->time_base;
263  } else if (tinterlace->mode != MODE_PAD) {
264  outlink->frame_rate = av_mul_q(inlink->frame_rate, (AVRational){1,2});
265  outlink->time_base = av_mul_q(inlink->time_base , (AVRational){2,1});
266  }
267 
268  for (i = 0; i<FF_ARRAY_ELEMS(standard_tbs); i++){
269  if (!av_cmp_q(standard_tbs[i], outlink->time_base))
270  break;
271  }
272  if (i == FF_ARRAY_ELEMS(standard_tbs) ||
273  (tinterlace->flags & TINTERLACE_FLAG_EXACT_TB))
274  outlink->time_base = tinterlace->preout_time_base;
275 
276  tinterlace->csp = av_pix_fmt_desc_get(outlink->format);
277  if (tinterlace->flags & TINTERLACE_FLAG_CVLPF) {
278  if (tinterlace->csp->comp[0].depth > 8)
279  tinterlace->lowpass_line = lowpass_line_complex_c_16;
280  else
281  tinterlace->lowpass_line = lowpass_line_complex_c;
282 #if ARCH_X86
283  ff_tinterlace_init_x86(tinterlace);
284 #endif
285  } else if (tinterlace->flags & TINTERLACE_FLAG_VLPF) {
286  if (tinterlace->csp->comp[0].depth > 8)
287  tinterlace->lowpass_line = lowpass_line_c_16;
288  else
289  tinterlace->lowpass_line = lowpass_line_c;
290 #if ARCH_X86
291  ff_tinterlace_init_x86(tinterlace);
292 #endif
293  }
294 
295  ret = ff_ccfifo_init(&tinterlace->cc_fifo, outlink->frame_rate, ctx);
296  if (ret < 0) {
297  av_log(ctx, AV_LOG_ERROR, "Failure to setup CC FIFO queue\n");
298  return ret;
299  }
300 
301  av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n", tinterlace->mode,
302  (tinterlace->flags & TINTERLACE_FLAG_CVLPF) ? "complex" :
303  (tinterlace->flags & TINTERLACE_FLAG_VLPF) ? "linear" : "off",
304  inlink->h, outlink->h);
305 
306  return 0;
307 }
308 
309 #define FIELD_UPPER 0
310 #define FIELD_LOWER 1
311 #define FIELD_UPPER_AND_LOWER 2
312 
313 /**
314  * Copy picture field from src to dst.
315  *
316  * @param src_field copy from upper, lower field or both
317  * @param interleave leave a padding line between each copied line
318  * @param dst_field copy to upper or lower field,
319  * only meaningful when interleave is selected
320  * @param flags context flags
321  */
322 static inline
323 void copy_picture_field(TInterlaceContext *tinterlace,
324  uint8_t *dst[4], int dst_linesize[4],
325  const uint8_t *src[4], int src_linesize[4],
326  enum AVPixelFormat format, int w, int src_h,
327  int src_field, int interleave, int dst_field,
328  int flags)
329 {
330  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(format);
331  int hsub = desc->log2_chroma_w;
332  int plane, vsub = desc->log2_chroma_h;
333  int k = src_field == FIELD_UPPER_AND_LOWER ? 1 : 2;
334  int h;
335 
336  for (plane = 0; plane < desc->nb_components; plane++) {
337  int lines = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(src_h, vsub) : src_h;
338  int cols = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT( w, hsub) : w;
339  uint8_t *dstp = dst[plane];
340  const uint8_t *srcp = src[plane];
341  int srcp_linesize = src_linesize[plane] * k;
342  int dstp_linesize = dst_linesize[plane] * (interleave ? 2 : 1);
343  int clip_max = (1 << tinterlace->csp->comp[plane].depth) - 1;
344 
345  lines = (lines + (src_field == FIELD_UPPER)) / k;
346  if (src_field == FIELD_LOWER)
347  srcp += src_linesize[plane];
348  if (interleave && dst_field == FIELD_LOWER)
349  dstp += dst_linesize[plane];
350  // Low-pass filtering is required when creating an interlaced destination from
351  // a progressive source which contains high-frequency vertical detail.
352  // Filtering will reduce interlace 'twitter' and Moire patterning.
353  if (flags & (TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF)) {
354  int x = !!(flags & TINTERLACE_FLAG_CVLPF);
355  for (h = lines; h > 0; h--) {
356  ptrdiff_t pref = src_linesize[plane];
357  ptrdiff_t mref = -pref;
358  if (h >= (lines - x)) mref = 0; // there is no line above
359  else if (h <= (1 + x)) pref = 0; // there is no line below
360 
361  tinterlace->lowpass_line(dstp, cols, srcp, mref, pref, clip_max);
362  dstp += dstp_linesize;
363  srcp += srcp_linesize;
364  }
365  } else {
366  if (tinterlace->csp->comp[plane].depth > 8)
367  cols *= 2;
368  av_image_copy_plane(dstp, dstp_linesize, srcp, srcp_linesize, cols, lines);
369  }
370  }
371 }
372 
373 static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
374 {
375  AVFilterContext *ctx = inlink->dst;
376  AVFilterLink *outlink = ctx->outputs[0];
377  TInterlaceContext *tinterlace = ctx->priv;
378  AVFrame *cur, *next, *out;
379  int field, tff, full, ret;
380 
381  av_frame_free(&tinterlace->cur);
382  tinterlace->cur = tinterlace->next;
383  tinterlace->next = picref;
384 
385  ff_ccfifo_extract(&tinterlace->cc_fifo, picref);
386 
387  cur = tinterlace->cur;
388  next = tinterlace->next;
389  /* we need at least two frames */
390  if (!tinterlace->cur)
391  return 0;
392 
393  switch (tinterlace->mode) {
394  case MODE_MERGEX2: /* move the odd frame into the upper field of the new image, even into
395  * the lower field, generating a double-height video at same framerate */
396  case MODE_MERGE: /* move the odd frame into the upper field of the new image, even into
397  * the lower field, generating a double-height video at half framerate */
398  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
399  if (!out)
400  return AVERROR(ENOMEM);
401  av_frame_copy_props(out, cur);
402  out->height = outlink->h;
403 #if FF_API_INTERLACED_FRAME
404 FF_DISABLE_DEPRECATION_WARNINGS
405  out->interlaced_frame = 1;
406  out->top_field_first = 1;
407 FF_ENABLE_DEPRECATION_WARNINGS
408 #endif
409  out->flags |= AV_FRAME_FLAG_INTERLACED | AV_FRAME_FLAG_TOP_FIELD_FIRST;
410  out->sample_aspect_ratio = av_mul_q(cur->sample_aspect_ratio, av_make_q(2, 1));
411 
412  /* write odd frame lines into the upper field of the new frame */
413  copy_picture_field(tinterlace, out->data, out->linesize,
414  (const uint8_t **)cur->data, cur->linesize,
415  inlink->format, inlink->w, inlink->h,
416  FIELD_UPPER_AND_LOWER, 1, tinterlace->mode == MODE_MERGEX2 ? (1 + inlink->frame_count_out) & 1 ? FIELD_LOWER : FIELD_UPPER : FIELD_UPPER, tinterlace->flags);
417  /* write even frame lines into the lower field of the new frame */
418  copy_picture_field(tinterlace, out->data, out->linesize,
419  (const uint8_t **)next->data, next->linesize,
420  inlink->format, inlink->w, inlink->h,
421  FIELD_UPPER_AND_LOWER, 1, tinterlace->mode == MODE_MERGEX2 ? (1 + inlink->frame_count_out) & 1 ? FIELD_UPPER : FIELD_LOWER : FIELD_LOWER, tinterlace->flags);
422  if (tinterlace->mode != MODE_MERGEX2)
423  av_frame_free(&tinterlace->next);
424  break;
425 
426  case MODE_DROP_ODD: /* only output even frames, odd frames are dropped; height unchanged, half framerate */
427  case MODE_DROP_EVEN: /* only output odd frames, even frames are dropped; height unchanged, half framerate */
428  out = av_frame_clone(tinterlace->mode == MODE_DROP_EVEN ? cur : next);
429  if (!out)
430  return AVERROR(ENOMEM);
431  av_frame_free(&tinterlace->next);
432  break;
433 
434  case MODE_PAD: /* expand each frame to double height, but pad alternate
435  * lines with black; framerate unchanged */
436  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
437  if (!out)
438  return AVERROR(ENOMEM);
439  av_frame_copy_props(out, cur);
440  out->height = outlink->h;
441  out->sample_aspect_ratio = av_mul_q(cur->sample_aspect_ratio, av_make_q(2, 1));
442 
443  field = (1 + outlink->frame_count_in) & 1 ? FIELD_UPPER : FIELD_LOWER;
444  full = out->color_range == AVCOL_RANGE_JPEG || ff_fmt_is_in(out->format, full_scale_yuvj_pix_fmts);
445  /* copy upper and lower fields */
446  copy_picture_field(tinterlace, out->data, out->linesize,
447  (const uint8_t **)cur->data, cur->linesize,
448  inlink->format, inlink->w, inlink->h,
449  FIELD_UPPER_AND_LOWER, 1, field, tinterlace->flags);
450  /* pad with black the other field */
451  copy_picture_field(tinterlace, out->data, out->linesize,
452  (const uint8_t **)tinterlace->black_data[full], tinterlace->black_linesize,
453  inlink->format, inlink->w, inlink->h,
454  FIELD_UPPER_AND_LOWER, 1, !field, tinterlace->flags);
455  break;
456 
457  /* interleave upper/lower lines from odd frames with lower/upper lines from even frames,
458  * halving the frame rate and preserving image height */
459  case MODE_INTERLEAVE_TOP: /* top field first */
460  case MODE_INTERLEAVE_BOTTOM: /* bottom field first */
461  if ((tinterlace->flags & TINTERLACE_FLAG_BYPASS_IL) && (cur->flags & AV_FRAME_FLAG_INTERLACED)) {
462  av_log(ctx, AV_LOG_WARNING,
463  "video is already interlaced, adjusting framerate only\n");
464  out = av_frame_clone(cur);
465  if (!out)
466  return AVERROR(ENOMEM);
467  out->pts /= 2; // adjust pts to new framerate
468  ff_ccfifo_inject(&tinterlace->cc_fifo, out);
469  ret = ff_filter_frame(outlink, out);
470  return ret;
471  }
472  tff = tinterlace->mode == MODE_INTERLEAVE_TOP;
473  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
474  if (!out)
475  return AVERROR(ENOMEM);
476  av_frame_copy_props(out, cur);
477 #if FF_API_INTERLACED_FRAME
478 FF_DISABLE_DEPRECATION_WARNINGS
479  out->interlaced_frame = 1;
480  out->top_field_first = tff;
481 FF_ENABLE_DEPRECATION_WARNINGS
482 #endif
483  out->flags |= AV_FRAME_FLAG_INTERLACED;
484  if (tff)
485  out->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
486  else
487  out->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
488 
489  /* copy upper/lower field from cur */
490  copy_picture_field(tinterlace, out->data, out->linesize,
491  (const uint8_t **)cur->data, cur->linesize,
492  inlink->format, inlink->w, inlink->h,
493  tff ? FIELD_UPPER : FIELD_LOWER, 1, tff ? FIELD_UPPER : FIELD_LOWER,
494  tinterlace->flags);
495  /* copy lower/upper field from next */
496  copy_picture_field(tinterlace, out->data, out->linesize,
497  (const uint8_t **)next->data, next->linesize,
498  inlink->format, inlink->w, inlink->h,
499  tff ? FIELD_LOWER : FIELD_UPPER, 1, tff ? FIELD_LOWER : FIELD_UPPER,
500  tinterlace->flags);
501  av_frame_free(&tinterlace->next);
502  break;
503  case MODE_INTERLACEX2: /* re-interlace preserving image height, double frame rate */
504  /* output current frame first */
505  out = av_frame_clone(cur);
506  if (!out)
507  return AVERROR(ENOMEM);
508 #if FF_API_INTERLACED_FRAME
509 FF_DISABLE_DEPRECATION_WARNINGS
510  out->interlaced_frame = 1;
511 FF_ENABLE_DEPRECATION_WARNINGS
512 #endif
513  out->flags |= AV_FRAME_FLAG_INTERLACED;
514  if (cur->pts != AV_NOPTS_VALUE)
515  out->pts = cur->pts*2;
516 
517  out->pts = av_rescale_q(out->pts, tinterlace->preout_time_base, outlink->time_base);
518  ff_ccfifo_inject(&tinterlace->cc_fifo, out);
519  if ((ret = ff_filter_frame(outlink, out)) < 0)
520  return ret;
521 
522  /* output mix of current and next frame */
523  tff = !!(next->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
524  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
525  if (!out)
526  return AVERROR(ENOMEM);
527  av_frame_copy_props(out, next);
528 #if FF_API_INTERLACED_FRAME
529 FF_DISABLE_DEPRECATION_WARNINGS
530  out->interlaced_frame = 1;
531  out->top_field_first = !tff;
532 FF_ENABLE_DEPRECATION_WARNINGS
533 #endif
534  out->flags |= AV_FRAME_FLAG_INTERLACED;
535  if (tff)
536  out->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
537  else
538  out->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
539 
540  if (next->pts != AV_NOPTS_VALUE && cur->pts != AV_NOPTS_VALUE)
541  out->pts = cur->pts + next->pts;
542  else
543  out->pts = AV_NOPTS_VALUE;
544  /* write current frame second field lines into the second field of the new frame */
545  copy_picture_field(tinterlace, out->data, out->linesize,
546  (const uint8_t **)cur->data, cur->linesize,
547  inlink->format, inlink->w, inlink->h,
548  tff ? FIELD_LOWER : FIELD_UPPER, 1, tff ? FIELD_LOWER : FIELD_UPPER,
549  tinterlace->flags);
550  /* write next frame first field lines into the first field of the new frame */
551  copy_picture_field(tinterlace, out->data, out->linesize,
552  (const uint8_t **)next->data, next->linesize,
553  inlink->format, inlink->w, inlink->h,
554  tff ? FIELD_UPPER : FIELD_LOWER, 1, tff ? FIELD_UPPER : FIELD_LOWER,
555  tinterlace->flags);
556  break;
557  default:
558  av_assert0(0);
559  }
560 
561  out->pts = av_rescale_q(out->pts, tinterlace->preout_time_base, outlink->time_base);
562  out->duration = av_rescale_q(1, av_inv_q(outlink->frame_rate), outlink->time_base);
563  ff_ccfifo_inject(&tinterlace->cc_fifo, out);
564  ret = ff_filter_frame(outlink, out);
565 
566  return ret;
567 }
568 
569 static int init_interlace(AVFilterContext *ctx)
570 {
571  TInterlaceContext *tinterlace = ctx->priv;
572 
573  if (tinterlace->mode <= MODE_BFF)
574  tinterlace->mode += MODE_INTERLEAVE_TOP;
575 
576  tinterlace->flags |= TINTERLACE_FLAG_BYPASS_IL;
577  if (tinterlace->lowpass == VLPF_LIN)
578  tinterlace->flags |= TINTERLACE_FLAG_VLPF;
579  if (tinterlace->lowpass == VLPF_CMP)
580  tinterlace->flags |= TINTERLACE_FLAG_CVLPF;
581 
582  return 0;
583 }
584 
585 static const AVFilterPad tinterlace_inputs[] = {
586  {
587  .name = "default",
588  .type = AVMEDIA_TYPE_VIDEO,
589  .filter_frame = filter_frame,
590  },
591 };
592 
593 static const AVFilterPad tinterlace_outputs[] = {
594  {
595  .name = "default",
596  .type = AVMEDIA_TYPE_VIDEO,
597  .config_props = config_out_props,
598  },
599 };
600 
601 const AVFilter ff_vf_tinterlace = {
602  .name = "tinterlace",
603  .description = NULL_IF_CONFIG_SMALL("Perform temporal field interlacing."),
604  .priv_size = sizeof(TInterlaceContext),
605  .uninit = uninit,
606  FILTER_INPUTS(tinterlace_inputs),
607  FILTER_OUTPUTS(tinterlace_outputs),
608  FILTER_PIXFMTS_ARRAY(pix_fmts),
609  .priv_class = &tinterlace_class,
610 };
611 
612 
613 const AVFilter ff_vf_interlace = {
614  .name = "interlace",
615  .description = NULL_IF_CONFIG_SMALL("Convert progressive video into interlaced."),
616  .priv_size = sizeof(TInterlaceContext),
617  .init = init_interlace,
618  .uninit = uninit,
619  FILTER_INPUTS(tinterlace_inputs),
620  FILTER_OUTPUTS(tinterlace_outputs),
621  FILTER_PIXFMTS_ARRAY(pix_fmts),
622  .priv_class = &interlace_class,
623 };
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
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
Definition: vf_tinterlace.c:373
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
MODE_MERGE
@ MODE_MERGE
Definition: tinterlace.h:49
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
av_clip
#define av_clip
Definition: common.h:98
init_interlace
static int init_interlace(AVFilterContext *ctx)
Definition: vf_tinterlace.c:569
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
out
FILE * out
Definition: movenc.c:54
TINTERLACE_FLAG_BYPASS_IL
#define TINTERLACE_FLAG_BYPASS_IL
Definition: tinterlace.h:40
standard_tbs
static const AVRational standard_tbs[]
Definition: vf_tinterlace.c:85
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
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
TInterlaceContext::lowpass_line
void(* lowpass_line)(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp, ptrdiff_t mref, ptrdiff_t pref, int clip_max)
Definition: tinterlace.h:79
lowpass_line_complex_c
static void lowpass_line_complex_c(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp, ptrdiff_t mref, ptrdiff_t pref, int clip_max)
Definition: vf_tinterlace.c:137
FIELD_UPPER_AND_LOWER
#define FIELD_UPPER_AND_LOWER
Definition: vf_tinterlace.c:311
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:130
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:344
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:456
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
TInterlaceContext
Definition: tinterlace.h:65
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
TInterlaceContext::color
FFDrawColor color
Definition: tinterlace.h:77
AVOption
AVOption.
Definition: opt.h:346
TInterlaceContext::black_linesize
int black_linesize[4]
Definition: tinterlace.h:75
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
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:616
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
video.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:365
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:73
VLPF_LIN
@ VLPF_LIN
Definition: tinterlace.h:44
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:608
MODE_INTERLEAVE_TOP
@ MODE_INTERLEAVE_TOP
Definition: tinterlace.h:53
TInterlaceContext::vsub
int vsub
chroma vertical subsampling
Definition: tinterlace.h:71
TInterlaceContext::preout_time_base
AVRational preout_time_base
Definition: tinterlace.h:68
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:268
OFFSET
#define OFFSET(x)
Definition: vf_tinterlace.c:37
config_out_props
static int config_out_props(AVFilterLink *outlink)
Definition: vf_tinterlace.c:210
FIELD_LOWER
#define FIELD_LOWER
Definition: vf_tinterlace.c:310
ff_ccfifo_uninit
void ff_ccfifo_uninit(CCFifo *ccf)
Free all memory allocated in a CCFifo and clear the context.
Definition: ccfifo.c:46
tinterlace_inputs
static const AVFilterPad tinterlace_inputs[]
Definition: vf_tinterlace.c:585
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:156
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_tinterlace.c:199
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:276
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
MODE_MERGEX2
@ MODE_MERGEX2
Definition: tinterlace.h:56
ff_ccfifo_inject
int ff_ccfifo_inject(CCFifo *ccf, AVFrame *frame)
Insert CC data from the FIFO into an AVFrame (as side data)
Definition: ccfifo.c:133
TInterlaceContext::flags
int flags
flags affecting interlacing algorithm
Definition: tinterlace.h:69
TInterlaceContext::csp
const AVPixFmtDescriptor * csp
Definition: tinterlace.h:78
width
#define width
TInterlaceContext::cur
AVFrame * cur
Definition: tinterlace.h:72
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_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
VLPF_CMP
@ VLPF_CMP
Definition: tinterlace.h:45
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
TInterlaceContext::next
AVFrame * next
Definition: tinterlace.h:73
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:563
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
field
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 field
Definition: writing_filters.txt:78
TInterlaceContext::black_data
uint8_t * black_data[2][4]
buffer used to fill padded lines (limited/full)
Definition: tinterlace.h:74
ff_tinterlace_init_x86
void ff_tinterlace_init_x86(TInterlaceContext *interlace)
Definition: vf_tinterlace_init.c:57
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
ff_vf_tinterlace
const AVFilter ff_vf_tinterlace
Definition: vf_tinterlace.c:601
TInterlaceContext::cc_fifo
CCFifo cc_fifo
Definition: tinterlace.h:81
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:162
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:184
TINTERLACE_FLAG_EXACT_TB
#define TINTERLACE_FLAG_EXACT_TB
Definition: tinterlace.h:39
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:679
tinterlace_options
static const AVOption tinterlace_options[]
Definition: vf_tinterlace.c:40
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_vf_interlace
const AVFilter ff_vf_interlace
Definition: vf_tinterlace.c:613
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:415
TInterlaceContext::mode
int mode
TInterlaceMode, interlace mode selected.
Definition: tinterlace.h:67
ff_ccfifo_extract
int ff_ccfifo_extract(CCFifo *ccf, AVFrame *frame)
Extract CC data from an AVFrame.
Definition: ccfifo.c:183
ff_fmt_is_in
int ff_fmt_is_in(int fmt, const int *fmts)
Tell if an integer is contained in the provided -1-terminated list of integers.
Definition: formats.c:406
MODE_DROP_EVEN
@ MODE_DROP_EVEN
Definition: tinterlace.h:50
FFDrawColor::u8
uint8_t u8[16]
Definition: drawutils.h:55
AV_PIX_FMT_YUV440P10LE
@ AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:298
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
av_image_alloc
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
Definition: imgutils.c:218
interleave
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:110
lowpass
@ lowpass
Definition: af_biquads.c:86
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_PIX_FMT_YUV440P12LE
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:300
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
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_tinterlace.c:91
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:158
ff_draw_init2
int ff_draw_init2(FFDrawContext *draw, enum AVPixelFormat format, enum AVColorSpace csp, enum AVColorRange range, unsigned flags)
Init a draw context.
Definition: drawutils.c:80
TINTERLACE_FLAG_CVLPF
#define TINTERLACE_FLAG_CVLPF
Definition: tinterlace.h:38
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ff_fill_rectangle
void ff_fill_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_x, int dst_y, int w, int h)
Fill a rectangle with an uniform color.
Definition: drawutils.c:231
av_le2ne16
#define av_le2ne16(x)
Definition: bswap.h:97
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
FULL_SCALE_YUVJ_FORMATS
#define FULL_SCALE_YUVJ_FORMATS
Definition: vf_tinterlace.c:78
copy_picture_field
static void copy_picture_field(TInterlaceContext *tinterlace, uint8_t *dst[4], int dst_linesize[4], const uint8_t *src[4], int src_linesize[4], enum AVPixelFormat format, int w, int src_h, int src_field, int interleave, int dst_field, int flags)
Copy picture field from src to dst.
Definition: vf_tinterlace.c:323
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:182
internal.h
MODE_NB
@ MODE_NB
Definition: avf_avectorscope.c:41
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
MODE_INTERLEAVE_BOTTOM
@ MODE_INTERLEAVE_BOTTOM
Definition: tinterlace.h:54
FIELD_UPPER
#define FIELD_UPPER
Definition: vf_tinterlace.c:309
MODE_BFF
@ MODE_BFF
Definition: tinterlace.h:62
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:603
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:156
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVFilter
Filter definition.
Definition: avfilter.h:166
ff_ccfifo_init
int ff_ccfifo_init(CCFifo *ccf, AVRational framerate, void *log_ctx)
Initialize a CCFifo.
Definition: ccfifo.c:53
TInterlaceContext::lowpass
int lowpass
legacy interlace filter lowpass mode
Definition: tinterlace.h:70
ret
ret
Definition: filter_design.txt:187
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:451
tinterlace.h
AVRational::den
int den
Denominator.
Definition: rational.h:60
mode
mode
Definition: ebur128.h:83
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
MODE_PAD
@ MODE_PAD
Definition: tinterlace.h:52
avfilter.h
TInterlaceContext::draw
FFDrawContext draw
Definition: tinterlace.h:76
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
av_clip_uint8
#define av_clip_uint8
Definition: common.h:104
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:407
MODE_INTERLACEX2
@ MODE_INTERLACEX2
Definition: tinterlace.h:55
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
lowpass_line_c
static void lowpass_line_c(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp, ptrdiff_t mref, ptrdiff_t pref, int clip_max)
Definition: vf_tinterlace.c:105
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
VLPF_OFF
@ VLPF_OFF
Definition: tinterlace.h:43
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
full_scale_yuvj_pix_fmts
static enum AVPixelFormat full_scale_yuvj_pix_fmts[]
Definition: vf_tinterlace.c:81
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:186
lowpass_line_complex_c_16
static void lowpass_line_complex_c_16(uint8_t *dst8, ptrdiff_t width, const uint8_t *src8, ptrdiff_t mref, ptrdiff_t pref, int clip_max)
Definition: vf_tinterlace.c:164
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FFDrawColor::comp
union FFDrawColor::@248 comp[MAX_PLANES]
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
MODE_TFF
@ MODE_TFF
Definition: tinterlace.h:61
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
TINTERLACE_FLAG_VLPF
#define TINTERLACE_FLAG_VLPF
Definition: tinterlace.h:37
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
imgutils.h
interlace_options
static const AVOption interlace_options[]
Definition: vf_tinterlace.c:64
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
lowpass_line_c_16
static void lowpass_line_c_16(uint8_t *dst8, ptrdiff_t width, const uint8_t *src8, ptrdiff_t mref, ptrdiff_t pref, int clip_max)
Definition: vf_tinterlace.c:119
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:389
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
h
h
Definition: vp9dsp_template.c:2038
FLAGS
#define FLAGS
Definition: vf_tinterlace.c:38
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:272
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(tinterlace)
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
MODE_DROP_ODD
@ MODE_DROP_ODD
Definition: tinterlace.h:51
tinterlace_outputs
static const AVFilterPad tinterlace_outputs[]
Definition: vf_tinterlace.c:593
Generated on Thu Apr 18 2024 22:45:38 for FFmpeg by   doxygen 1.8.17