FFmpeg  4.3
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 
127  /* Only edge pixels need to be processed here. A constant value of false
128  * for is_not_edge should let the compiler ignore the whole branch. */
129  FILTER(0, 3, 0)
130 
131  dst = (uint8_t*)dst1 + w - edge;
132  prev = (uint8_t*)prev1 + w - edge;
133  cur = (uint8_t*)cur1 + w - edge;
134  next = (uint8_t*)next1 + w - edge;
135  prev2 = (uint8_t*)(parity ? prev : cur);
136  next2 = (uint8_t*)(parity ? cur : next);
137 
138  FILTER(w - edge, w - 3, 1)
139  FILTER(w - 3, w, 0)
140 }
141 
142 
143 static void filter_line_c_16bit(void *dst1,
144  void *prev1, void *cur1, void *next1,
145  int w, int prefs, int mrefs, int parity,
146  int mode)
147 {
148  uint16_t *dst = dst1;
149  uint16_t *prev = prev1;
150  uint16_t *cur = cur1;
151  uint16_t *next = next1;
152  int x;
153  uint16_t *prev2 = parity ? prev : cur ;
154  uint16_t *next2 = parity ? cur : next;
155  mrefs /= 2;
156  prefs /= 2;
157 
158  FILTER(0, w, 1)
159 }
160 
161 static void filter_edges_16bit(void *dst1, void *prev1, void *cur1, void *next1,
162  int w, int prefs, int mrefs, int parity, int mode)
163 {
164  uint16_t *dst = dst1;
165  uint16_t *prev = prev1;
166  uint16_t *cur = cur1;
167  uint16_t *next = next1;
168  int x;
169  uint16_t *prev2 = parity ? prev : cur ;
170  uint16_t *next2 = parity ? cur : next;
171 
172  const int edge = MAX_ALIGN / 2 - 1;
173 
174  mrefs /= 2;
175  prefs /= 2;
176 
177  FILTER(0, 3, 0)
178 
179  dst = (uint16_t*)dst1 + w - edge;
180  prev = (uint16_t*)prev1 + w - edge;
181  cur = (uint16_t*)cur1 + w - edge;
182  next = (uint16_t*)next1 + w - edge;
183  prev2 = (uint16_t*)(parity ? prev : cur);
184  next2 = (uint16_t*)(parity ? cur : next);
185 
186  FILTER(w - edge, w - 3, 1)
187  FILTER(w - 3, w, 0)
188 }
189 
190 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
191 {
192  YADIFContext *s = ctx->priv;
193  ThreadData *td = arg;
194  int refs = s->cur->linesize[td->plane];
195  int df = (s->csp->comp[td->plane].depth + 7) / 8;
196  int pix_3 = 3 * df;
197  int slice_start = (td->h * jobnr ) / nb_jobs;
198  int slice_end = (td->h * (jobnr+1)) / nb_jobs;
199  int y;
200  int edge = 3 + MAX_ALIGN / df - 1;
201 
202  /* filtering reads 3 pixels to the left/right; to avoid invalid reads,
203  * we need to call the c variant which avoids this for border pixels
204  */
205  for (y = slice_start; y < slice_end; y++) {
206  if ((y ^ td->parity) & 1) {
207  uint8_t *prev = &s->prev->data[td->plane][y * refs];
208  uint8_t *cur = &s->cur ->data[td->plane][y * refs];
209  uint8_t *next = &s->next->data[td->plane][y * refs];
210  uint8_t *dst = &td->frame->data[td->plane][y * td->frame->linesize[td->plane]];
211  int mode = y == 1 || y + 2 == td->h ? 2 : s->mode;
212  s->filter_line(dst + pix_3, prev + pix_3, cur + pix_3,
213  next + pix_3, td->w - edge,
214  y + 1 < td->h ? refs : -refs,
215  y ? -refs : refs,
216  td->parity ^ td->tff, mode);
217  s->filter_edges(dst, prev, cur, next, td->w,
218  y + 1 < td->h ? refs : -refs,
219  y ? -refs : refs,
220  td->parity ^ td->tff, mode);
221  } else {
222  memcpy(&td->frame->data[td->plane][y * td->frame->linesize[td->plane]],
223  &s->cur->data[td->plane][y * refs], td->w * df);
224  }
225  }
226  return 0;
227 }
228 
229 static void filter(AVFilterContext *ctx, AVFrame *dstpic,
230  int parity, int tff)
231 {
232  YADIFContext *yadif = ctx->priv;
233  ThreadData td = { .frame = dstpic, .parity = parity, .tff = tff };
234  int i;
235 
236  for (i = 0; i < yadif->csp->nb_components; i++) {
237  int w = dstpic->width;
238  int h = dstpic->height;
239 
240  if (i == 1 || i == 2) {
241  w = AV_CEIL_RSHIFT(w, yadif->csp->log2_chroma_w);
242  h = AV_CEIL_RSHIFT(h, yadif->csp->log2_chroma_h);
243  }
244 
245 
246  td.w = w;
247  td.h = h;
248  td.plane = i;
249 
251  }
252 
253  emms_c();
254 }
255 
257 {
258  YADIFContext *yadif = ctx->priv;
259 
260  av_frame_free(&yadif->prev);
261  av_frame_free(&yadif->cur );
262  av_frame_free(&yadif->next);
263 }
264 
266 {
267  static const enum AVPixelFormat pix_fmts[] = {
283  };
284 
286  if (!fmts_list)
287  return AVERROR(ENOMEM);
288  return ff_set_common_formats(ctx, fmts_list);
289 }
290 
291 static int config_output(AVFilterLink *outlink)
292 {
293  AVFilterContext *ctx = outlink->src;
294  YADIFContext *s = ctx->priv;
295 
296  outlink->time_base.num = ctx->inputs[0]->time_base.num;
297  outlink->time_base.den = ctx->inputs[0]->time_base.den * 2;
298  outlink->w = ctx->inputs[0]->w;
299  outlink->h = ctx->inputs[0]->h;
300 
301  if(s->mode & 1)
302  outlink->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
303  (AVRational){2, 1});
304 
305  if (outlink->w < 3 || outlink->h < 3) {
306  av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or lines is not supported\n");
307  return AVERROR(EINVAL);
308  }
309 
310  s->csp = av_pix_fmt_desc_get(outlink->format);
311  s->filter = filter;
312  if (s->csp->comp[0].depth > 8) {
313  s->filter_line = filter_line_c_16bit;
314  s->filter_edges = filter_edges_16bit;
315  } else {
316  s->filter_line = filter_line_c;
317  s->filter_edges = filter_edges;
318  }
319 
320  if (ARCH_X86)
322 
323  return 0;
324 }
325 
326 
327 static const AVClass yadif_class = {
328  .class_name = "yadif",
329  .item_name = av_default_item_name,
330  .option = ff_yadif_options,
331  .version = LIBAVUTIL_VERSION_INT,
332  .category = AV_CLASS_CATEGORY_FILTER,
333 };
334 
336  {
337  .name = "default",
338  .type = AVMEDIA_TYPE_VIDEO,
339  .filter_frame = ff_yadif_filter_frame,
340  },
341  { NULL }
342 };
343 
345  {
346  .name = "default",
347  .type = AVMEDIA_TYPE_VIDEO,
348  .request_frame = ff_yadif_request_frame,
349  .config_props = config_output,
350  },
351  { NULL }
352 };
353 
355  .name = "yadif",
356  .description = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
357  .priv_size = sizeof(YADIFContext),
358  .priv_class = &yadif_class,
359  .uninit = uninit,
364 };
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
ARCH_X86
#define ARCH_X86
Definition: config.h:38
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:2549
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:143
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:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
pixdesc.h
AVFrame::width
int width
Definition: frame.h:358
ThreadData::tff
int tff
Definition: vf_bwdif.c:57
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_yadif.c:265
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
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:148
video.h
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1788
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:415
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:413
x
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
Definition: fate.txt:150
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:395
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:381
AVRational::num
int num
Numerator.
Definition: rational.h:59
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:400
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:90
avfilter_vf_yadif_inputs
static const AVFilterPad avfilter_vf_yadif_inputs[]
Definition: vf_yadif.c:335
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:409
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:600
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_yadif.c:190
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
emms_c
#define emms_c()
Definition: internal.h:55
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:410
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:256
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2040
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:394
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:408
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:59
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:416
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:235
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
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:412
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:186
ThreadData::parity
int parity
Definition: vf_bwdif.c:56
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_yadif.c:291
cpu.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
avfilter_vf_yadif_outputs
static const AVFilterPad avfilter_vf_yadif_outputs[]
Definition: vf_yadif.c:344
parity
mcdeint parity
Definition: vf_mcdeint.c:274
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
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
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:269
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
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:161
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:784
ThreadData
Used for passing data between threads.
Definition: dsddec.c:67
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:396
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
w
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo ug o o w
Definition: fate.txt:150
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:401
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:406
AVFrame::height
int height
Definition: frame.h:358
YADIFContext::next
AVFrame * next
Definition: yadif.h:60
AVRational::den
int den
Denominator.
Definition: rational.h:60
filter
static void filter(AVFilterContext *ctx, AVFrame *dstpic, int parity, int tff)
Definition: vf_yadif.c:229
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
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:354
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:327
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:564
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:407
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:405