FFmpeg
vf_idet.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <float.h> /* FLT_MAX */
22 
23 #include "libavutil/cpu.h"
24 #include "libavutil/common.h"
25 #include "libavutil/opt.h"
26 #include "internal.h"
27 #include "vf_idet.h"
28 
29 #define OFFSET(x) offsetof(IDETContext, x)
30 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
31 
32 static const AVOption idet_options[] = {
33  { "intl_thres", "set interlacing threshold", OFFSET(interlace_threshold), AV_OPT_TYPE_FLOAT, {.dbl = 1.04}, -1, FLT_MAX, FLAGS },
34  { "prog_thres", "set progressive threshold", OFFSET(progressive_threshold), AV_OPT_TYPE_FLOAT, {.dbl = 1.5}, -1, FLT_MAX, FLAGS },
35  { "rep_thres", "set repeat threshold", OFFSET(repeat_threshold), AV_OPT_TYPE_FLOAT, {.dbl = 3.0}, -1, FLT_MAX, FLAGS },
36  { "half_life", "half life of cumulative statistics", OFFSET(half_life), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, -1, INT_MAX, FLAGS },
37  { "analyze_interlaced_flag", "set number of frames to use to determine if the interlace flag is accurate", OFFSET(analyze_interlaced_flag), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, FLAGS },
38  { NULL }
39 };
40 
42 
43 static const char *type2str(Type type)
44 {
45  switch(type) {
46  case TFF : return "tff";
47  case BFF : return "bff";
48  case PROGRESSIVE : return "progressive";
49  case UNDETERMINED : return "undetermined";
50  }
51  return NULL;
52 }
53 
54 #define PRECISION 1048576
55 
56 static uint64_t uintpow(uint64_t b,unsigned int e)
57 {
58  uint64_t r=1;
59  while(e--) r*=b;
60  return r;
61 }
62 
63 static int av_dict_set_fxp(AVDictionary **pm, const char *key, uint64_t value, unsigned int digits,
64  int flags)
65 {
66  char valuestr[44];
67  uint64_t print_precision = uintpow(10, digits);
68 
69  value = av_rescale(value, print_precision, PRECISION);
70 
71  snprintf(valuestr, sizeof(valuestr), "%"PRId64".%0*"PRId64,
72  value / print_precision, digits, value % print_precision);
73 
74  return av_dict_set(pm, key, valuestr, flags);
75 }
76 
77 static const char *rep2str(RepeatedField repeated_field)
78 {
79  switch(repeated_field) {
80  case REPEAT_NONE : return "neither";
81  case REPEAT_TOP : return "top";
82  case REPEAT_BOTTOM : return "bottom";
83  }
84  return NULL;
85 }
86 
87 int ff_idet_filter_line_c(const uint8_t *a, const uint8_t *b, const uint8_t *c, int w)
88 {
89  int x;
90  int ret=0;
91 
92  for(x=0; x<w; x++){
93  int v = (*a++ + *c++) - 2 * *b++;
94  ret += FFABS(v);
95  }
96 
97  return ret;
98 }
99 
100 int ff_idet_filter_line_c_16bit(const uint16_t *a, const uint16_t *b, const uint16_t *c, int w)
101 {
102  int x;
103  int ret=0;
104 
105  for(x=0; x<w; x++){
106  int v = (*a++ + *c++) - 2 * *b++;
107  ret += FFABS(v);
108  }
109 
110  return ret;
111 }
112 
114 {
115  IDETContext *idet = ctx->priv;
116  int y, i;
117  int64_t alpha[2]={0};
118  int64_t delta=0;
119  int64_t gamma[2]={0};
120  Type type, best_type;
121  RepeatedField repeat;
122  int match = 0;
123  AVDictionary **metadata = &idet->cur->metadata;
124 
125  for (i = 0; i < idet->csp->nb_components; i++) {
126  int w = idet->cur->width;
127  int h = idet->cur->height;
128  int refs = idet->cur->linesize[i];
129 
130  if (i && i<3) {
131  w = AV_CEIL_RSHIFT(w, idet->csp->log2_chroma_w);
132  h = AV_CEIL_RSHIFT(h, idet->csp->log2_chroma_h);
133  }
134 
135  for (y = 2; y < h - 2; y++) {
136  uint8_t *prev = &idet->prev->data[i][y*refs];
137  uint8_t *cur = &idet->cur ->data[i][y*refs];
138  uint8_t *next = &idet->next->data[i][y*refs];
139  alpha[ y &1] += idet->filter_line(cur-refs, prev, cur+refs, w);
140  alpha[(y^1)&1] += idet->filter_line(cur-refs, next, cur+refs, w);
141  delta += idet->filter_line(cur-refs, cur, cur+refs, w);
142  gamma[(y^1)&1] += idet->filter_line(cur , prev, cur , w);
143  }
144  }
145 
146  if (alpha[0] > idet->interlace_threshold * alpha[1]){
147  type = TFF;
148  }else if(alpha[1] > idet->interlace_threshold * alpha[0]){
149  type = BFF;
150  }else if(alpha[1] > idet->progressive_threshold * delta){
151  type = PROGRESSIVE;
152  }else{
153  type = UNDETERMINED;
154  }
155 
156  if ( gamma[0] > idet->repeat_threshold * gamma[1] ){
157  repeat = REPEAT_TOP;
158  } else if ( gamma[1] > idet->repeat_threshold * gamma[0] ){
159  repeat = REPEAT_BOTTOM;
160  } else {
161  repeat = REPEAT_NONE;
162  }
163 
164  memmove(idet->history+1, idet->history, HIST_SIZE-1);
165  idet->history[0] = type;
166  best_type = UNDETERMINED;
167  for(i=0; i<HIST_SIZE; i++){
168  if(idet->history[i] != UNDETERMINED){
169  if(best_type == UNDETERMINED)
170  best_type = idet->history[i];
171 
172  if(idet->history[i] == best_type) {
173  match++;
174  }else{
175  match=0;
176  break;
177  }
178  }
179  }
180  if(idet->last_type == UNDETERMINED){
181  if(match ) idet->last_type = best_type;
182  }else{
183  if(match>2) idet->last_type = best_type;
184  }
185 
186  if (idet->last_type == TFF){
187  idet->cur->top_field_first = 1;
188  idet->cur->interlaced_frame = 1;
189  }else if(idet->last_type == BFF){
190  idet->cur->top_field_first = 0;
191  idet->cur->interlaced_frame = 1;
192  }else if(idet->last_type == PROGRESSIVE){
193  idet->cur->interlaced_frame = 0;
194  }
195 
196  for(i=0; i<3; i++)
197  idet->repeats[i] = av_rescale(idet->repeats [i], idet->decay_coefficient, PRECISION);
198 
199  for(i=0; i<4; i++){
200  idet->prestat [i] = av_rescale(idet->prestat [i], idet->decay_coefficient, PRECISION);
201  idet->poststat[i] = av_rescale(idet->poststat[i], idet->decay_coefficient, PRECISION);
202  }
203 
204  idet->total_repeats [ repeat] ++;
205  idet->repeats [ repeat] += PRECISION;
206 
207  idet->total_prestat [ type] ++;
208  idet->prestat [ type] += PRECISION;
209 
210  idet->total_poststat[idet->last_type] ++;
211  idet->poststat [idet->last_type] += PRECISION;
212 
213  av_log(ctx, AV_LOG_DEBUG, "Repeated Field:%12s, Single frame:%12s, Multi frame:%12s\n",
214  rep2str(repeat), type2str(type), type2str(idet->last_type));
215 
216  av_dict_set (metadata, "lavfi.idet.repeated.current_frame", rep2str(repeat), 0);
217  av_dict_set_fxp(metadata, "lavfi.idet.repeated.neither", idet->repeats[REPEAT_NONE], 2, 0);
218  av_dict_set_fxp(metadata, "lavfi.idet.repeated.top", idet->repeats[REPEAT_TOP], 2, 0);
219  av_dict_set_fxp(metadata, "lavfi.idet.repeated.bottom", idet->repeats[REPEAT_BOTTOM], 2, 0);
220 
221  av_dict_set (metadata, "lavfi.idet.single.current_frame", type2str(type), 0);
222  av_dict_set_fxp(metadata, "lavfi.idet.single.tff", idet->prestat[TFF], 2 , 0);
223  av_dict_set_fxp(metadata, "lavfi.idet.single.bff", idet->prestat[BFF], 2, 0);
224  av_dict_set_fxp(metadata, "lavfi.idet.single.progressive", idet->prestat[PROGRESSIVE], 2, 0);
225  av_dict_set_fxp(metadata, "lavfi.idet.single.undetermined", idet->prestat[UNDETERMINED], 2, 0);
226 
227  av_dict_set (metadata, "lavfi.idet.multiple.current_frame", type2str(idet->last_type), 0);
228  av_dict_set_fxp(metadata, "lavfi.idet.multiple.tff", idet->poststat[TFF], 2, 0);
229  av_dict_set_fxp(metadata, "lavfi.idet.multiple.bff", idet->poststat[BFF], 2, 0);
230  av_dict_set_fxp(metadata, "lavfi.idet.multiple.progressive", idet->poststat[PROGRESSIVE], 2, 0);
231  av_dict_set_fxp(metadata, "lavfi.idet.multiple.undetermined", idet->poststat[UNDETERMINED], 2, 0);
232 }
233 
234 static int filter_frame(AVFilterLink *link, AVFrame *picref)
235 {
236  AVFilterContext *ctx = link->dst;
237  IDETContext *idet = ctx->priv;
238 
239  // initial frame(s) and not interlaced, just pass through for
240  // the analyze_interlaced_flag mode
241  if (idet->analyze_interlaced_flag &&
242  !picref->interlaced_frame &&
243  !idet->next) {
244  return ff_filter_frame(ctx->outputs[0], picref);
245  }
246  if (idet->analyze_interlaced_flag_done) {
247  if (picref->interlaced_frame && idet->interlaced_flag_accuracy < 0)
248  picref->interlaced_frame = 0;
249  return ff_filter_frame(ctx->outputs[0], picref);
250  }
251 
252  av_frame_free(&idet->prev);
253 
254  if( picref->width != link->w
255  || picref->height != link->h
256  || picref->format != link->format) {
257  link->dst->inputs[0]->format = picref->format;
258  link->dst->inputs[0]->w = picref->width;
259  link->dst->inputs[0]->h = picref->height;
260 
261  av_frame_free(&idet->cur );
262  av_frame_free(&idet->next);
263  }
264 
265  idet->prev = idet->cur;
266  idet->cur = idet->next;
267  idet->next = picref;
268 
269  if (!idet->cur &&
270  !(idet->cur = av_frame_clone(idet->next)))
271  return AVERROR(ENOMEM);
272 
273  if (!idet->prev)
274  return 0;
275 
276  if (!idet->csp)
278  if (idet->csp->comp[0].depth > 8){
280  if (ARCH_X86)
281  ff_idet_init_x86(idet, 1);
282  }
283 
284  if (idet->analyze_interlaced_flag) {
285  if (idet->cur->interlaced_frame) {
286  idet->cur->interlaced_frame = 0;
287  filter(ctx);
288  if (idet->last_type == PROGRESSIVE) {
289  idet->interlaced_flag_accuracy --;
290  idet->analyze_interlaced_flag --;
291  } else if (idet->last_type != UNDETERMINED) {
292  idet->interlaced_flag_accuracy ++;
293  idet->analyze_interlaced_flag --;
294  }
295  if (idet->analyze_interlaced_flag == 1) {
296  ff_filter_frame(ctx->outputs[0], av_frame_clone(idet->cur));
297 
298  if (idet->next->interlaced_frame && idet->interlaced_flag_accuracy < 0)
299  idet->next->interlaced_frame = 0;
301  av_log(ctx, AV_LOG_INFO, "Final flag accuracy %d\n", idet->interlaced_flag_accuracy);
302  return ff_filter_frame(ctx->outputs[0], av_frame_clone(idet->next));
303  }
304  }
305  } else {
306  filter(ctx);
307  }
308 
309  return ff_filter_frame(ctx->outputs[0], av_frame_clone(idet->cur));
310 }
311 
313 {
314  AVFilterContext *ctx = link->src;
315  IDETContext *idet = ctx->priv;
316  int ret;
317 
318  if (idet->eof)
319  return AVERROR_EOF;
320 
321  ret = ff_request_frame(link->src->inputs[0]);
322 
323  if (ret == AVERROR_EOF && idet->cur && !idet->analyze_interlaced_flag_done) {
324  AVFrame *next = av_frame_clone(idet->next);
325 
326  if (!next)
327  return AVERROR(ENOMEM);
328 
329  ret = filter_frame(link->src->inputs[0], next);
330  idet->eof = 1;
331  }
332 
333  return ret;
334 }
335 
337 {
338  IDETContext *idet = ctx->priv;
339  int level = strncmp(ctx->name, "auto-inserted", 13) ? AV_LOG_INFO : AV_LOG_DEBUG;
340 
341  av_log(ctx, level, "Repeated Fields: Neither:%6"PRId64" Top:%6"PRId64" Bottom:%6"PRId64"\n",
342  idet->total_repeats[REPEAT_NONE],
343  idet->total_repeats[REPEAT_TOP],
345  );
346  av_log(ctx, level, "Single frame detection: TFF:%6"PRId64" BFF:%6"PRId64" Progressive:%6"PRId64" Undetermined:%6"PRId64"\n",
347  idet->total_prestat[TFF],
348  idet->total_prestat[BFF],
349  idet->total_prestat[PROGRESSIVE],
351  );
352  av_log(ctx, level, "Multi frame detection: TFF:%6"PRId64" BFF:%6"PRId64" Progressive:%6"PRId64" Undetermined:%6"PRId64"\n",
353  idet->total_poststat[TFF],
354  idet->total_poststat[BFF],
357  );
358 
359  av_frame_free(&idet->prev);
360  av_frame_free(&idet->cur );
361  av_frame_free(&idet->next);
362 }
363 
365 {
366  static const enum AVPixelFormat pix_fmts[] = {
398  };
400  if (!fmts_list)
401  return AVERROR(ENOMEM);
402  return ff_set_common_formats(ctx, fmts_list);
403 }
404 
406 {
407  IDETContext *idet = ctx->priv;
408 
409  idet->eof = 0;
410  idet->last_type = UNDETERMINED;
411  memset(idet->history, UNDETERMINED, HIST_SIZE);
412 
413  if( idet->half_life > 0 )
414  idet->decay_coefficient = lrint( PRECISION * exp2(-1.0 / idet->half_life) );
415  else
417 
419 
420  if (ARCH_X86)
421  ff_idet_init_x86(idet, 0);
422 
423  return 0;
424 }
425 
426 static const AVFilterPad idet_inputs[] = {
427  {
428  .name = "default",
429  .type = AVMEDIA_TYPE_VIDEO,
430  .filter_frame = filter_frame,
431  },
432  { NULL }
433 };
434 
435 static const AVFilterPad idet_outputs[] = {
436  {
437  .name = "default",
438  .type = AVMEDIA_TYPE_VIDEO,
439  .request_frame = request_frame
440  },
441  { NULL }
442 };
443 
445  .name = "idet",
446  .description = NULL_IF_CONFIG_SMALL("Interlace detect Filter."),
447  .priv_size = sizeof(IDETContext),
448  .init = init,
449  .uninit = uninit,
451  .inputs = idet_inputs,
453  .priv_class = &idet_class,
454 };
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
type2str
static const char * type2str(Type type)
Definition: vf_idet.c:43
r
const char * r
Definition: vf_curves.c:116
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
request_frame
static int request_frame(AVFilterLink *link)
Definition: vf_idet.c:312
opt.h
PROGRESSIVE
@ PROGRESSIVE
in the bitstream is reported as 00b
Definition: vc1.h:149
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2541
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
IDETContext::filter_line
ff_idet_filter_func filter_line
Definition: vf_idet.h:64
IDETContext::half_life
float half_life
Definition: vf_idet.h:47
HIST_SIZE
#define HIST_SIZE
Definition: f_ebur128.c:65
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
AVFrame::width
int width
Definition: frame.h:361
w
uint8_t w
Definition: llviddspenc.c:39
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:438
AVOption
AVOption.
Definition: opt.h:248
b
#define b
Definition: input.c:41
REPEAT_NONE
@ REPEAT_NONE
Definition: vf_idet.h:37
REPEAT_BOTTOM
@ REPEAT_BOTTOM
Definition: vf_idet.h:39
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *picref)
Definition: vf_idet.c:234
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:395
float.h
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
AVDictionary
Definition: dict.c:30
IDETContext::analyze_interlaced_flag_done
int analyze_interlaced_flag_done
Definition: vf_idet.h:68
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:65
RepeatedField
RepeatedField
Definition: vf_idet.h:36
IDETContext
Definition: vf_idet.h:42
ff_idet_filter_line_c_16bit
int ff_idet_filter_line_c_16bit(const uint16_t *a, const uint16_t *b, const uint16_t *c, int w)
Definition: vf_idet.c:100
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(idet)
IDETContext::prestat
uint64_t prestat[4]
Definition: vf_idet.h:53
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:387
vf_idet.h
type
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 type
Definition: writing_filters.txt:86
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:373
IDETContext::interlace_threshold
float interlace_threshold
Definition: vf_idet.h:44
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:392
IDETContext::prev
AVFrame * prev
Definition: vf_idet.h:63
lrint
#define lrint
Definition: tablegen.h:53
BFF
@ BFF
Definition: vf_idet.h:31
av_cold
#define av_cold
Definition: attributes.h:90
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_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:401
IDETContext::next
AVFrame * next
Definition: vf_idet.h:62
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:580
REPEAT_TOP
@ REPEAT_TOP
Definition: vf_idet.h:38
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
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:402
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
av_dict_set_fxp
static int av_dict_set_fxp(AVDictionary **pm, const char *key, uint64_t value, unsigned int digits, int flags)
Definition: vf_idet.c:63
FLAGS
#define FLAGS
Definition: vf_idet.c:30
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
idet_outputs
static const AVFilterPad idet_outputs[]
Definition: vf_idet.c:435
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:386
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:400
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:423
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_idet.c:405
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:81
IDETContext::repeat_threshold
float repeat_threshold
Definition: vf_idet.h:46
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
IDETContext::eof
int eof
Definition: vf_idet.h:71
key
const char * key
Definition: hwcontext_opencl.c:168
IDETContext::csp
const AVPixFmtDescriptor * csp
Definition: vf_idet.h:70
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
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
idet_options
static const AVOption idet_options[]
Definition: vf_idet.c:32
ff_vf_idet
const AVFilter ff_vf_idet
Definition: vf_idet.c:444
NULL
#define NULL
Definition: coverity.c:32
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:72
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
idet_inputs
static const AVFilterPad idet_inputs[]
Definition: vf_idet.c:426
OFFSET
#define OFFSET(x)
Definition: vf_idet.c:29
uintpow
static uint64_t uintpow(uint64_t b, unsigned int e)
Definition: vf_idet.c:56
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
IDETContext::total_poststat
uint64_t total_poststat[4]
Definition: vf_idet.h:57
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
IDETContext::interlaced_flag_accuracy
int interlaced_flag_accuracy
Definition: vf_idet.h:66
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
cpu.h
filter
static void filter(AVFilterContext *ctx)
Definition: vf_idet.c:113
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_idet.c:336
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:376
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
ff_idet_filter_func
int(* ff_idet_filter_func)(const uint8_t *a, const uint8_t *b, const uint8_t *c, int w)
Definition: vf_idet.h:27
IDETContext::analyze_interlaced_flag
int analyze_interlaced_flag
Definition: vf_idet.h:67
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:433
Type
Type
Definition: vf_idet.h:29
i
int i
Definition: input.c:407
rep2str
static const char * rep2str(RepeatedField repeated_field)
Definition: vf_idet.c:77
common.h
delta
float delta
Definition: vorbis_enc_data.h:430
exp2
#define exp2(x)
Definition: libm.h:288
value
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 default value
Definition: writing_filters.txt:86
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
IDETContext::cur
AVFrame * cur
Definition: vf_idet.h:61
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:388
IDETContext::poststat
uint64_t poststat[4]
Definition: vf_idet.h:54
IDETContext::total_prestat
uint64_t total_prestat[4]
Definition: vf_idet.h:56
UNDETERMINED
@ UNDETERMINED
Definition: vf_idet.h:33
AVFilter
Filter definition.
Definition: avfilter.h:145
ret
ret
Definition: filter_design.txt:187
IDETContext::total_repeats
uint64_t total_repeats[3]
Definition: vf_idet.h:55
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:393
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:398
PRECISION
#define PRECISION
Definition: vf_idet.c:54
IDETContext::history
uint8_t history[HIST_SIZE]
Definition: vf_idet.h:59
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_idet.c:364
AVFrame::height
int height
Definition: frame.h:361
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:572
IDETContext::repeats
uint64_t repeats[3]
Definition: vf_idet.h:52
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:106
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:333
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_idet_filter_line_c
int ff_idet_filter_line_c(const uint8_t *a, const uint8_t *b, const uint8_t *c, int w)
Definition: vf_idet.c:87
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
IDETContext::decay_coefficient
uint64_t decay_coefficient
Definition: vf_idet.h:48
IDETContext::progressive_threshold
float progressive_threshold
Definition: vf_idet.h:45
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
TFF
@ TFF
Definition: vf_idet.h:30
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
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
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
h
h
Definition: vp9dsp_template.c:2038
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:399
IDETContext::last_type
Type last_type
Definition: vf_idet.h:50
snprintf
#define snprintf
Definition: snprintf.h:34
ff_idet_init_x86
void ff_idet_init_x86(IDETContext *idet, int for_16b)
Definition: vf_idet_init.c:69
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:90
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:397