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/common.h"
24 #include "libavutil/opt.h"
25 #include "internal.h"
26 #include "vf_idet.h"
27 
28 #define OFFSET(x) offsetof(IDETContext, x)
29 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
30 
31 static const AVOption idet_options[] = {
32  { "intl_thres", "set interlacing threshold", OFFSET(interlace_threshold), AV_OPT_TYPE_FLOAT, {.dbl = 1.04}, -1, FLT_MAX, FLAGS },
33  { "prog_thres", "set progressive threshold", OFFSET(progressive_threshold), AV_OPT_TYPE_FLOAT, {.dbl = 1.5}, -1, FLT_MAX, FLAGS },
34  { "rep_thres", "set repeat threshold", OFFSET(repeat_threshold), AV_OPT_TYPE_FLOAT, {.dbl = 3.0}, -1, FLT_MAX, FLAGS },
35  { "half_life", "half life of cumulative statistics", OFFSET(half_life), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, -1, INT_MAX, FLAGS },
36  { "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 },
37  { NULL }
38 };
39 
41 
42 static const char *type2str(Type type)
43 {
44  switch(type) {
45  case TFF : return "tff";
46  case BFF : return "bff";
47  case PROGRESSIVE : return "progressive";
48  case UNDETERMINED : return "undetermined";
49  }
50  return NULL;
51 }
52 
53 #define PRECISION 1048576
54 
55 static uint64_t uintpow(uint64_t b,unsigned int e)
56 {
57  uint64_t r=1;
58  while(e--) r*=b;
59  return r;
60 }
61 
62 static int av_dict_set_fxp(AVDictionary **pm, const char *key, uint64_t value, unsigned int digits,
63  int flags)
64 {
65  char valuestr[44];
66  uint64_t print_precision = uintpow(10, digits);
67 
68  value = av_rescale(value, print_precision, PRECISION);
69 
70  snprintf(valuestr, sizeof(valuestr), "%"PRId64".%0*"PRId64,
71  value / print_precision, digits, value % print_precision);
72 
73  return av_dict_set(pm, key, valuestr, flags);
74 }
75 
76 static const char *rep2str(RepeatedField repeated_field)
77 {
78  switch(repeated_field) {
79  case REPEAT_NONE : return "neither";
80  case REPEAT_TOP : return "top";
81  case REPEAT_BOTTOM : return "bottom";
82  }
83  return NULL;
84 }
85 
86 int ff_idet_filter_line_c(const uint8_t *a, const uint8_t *b, const uint8_t *c, int w)
87 {
88  int x;
89  int ret=0;
90 
91  for(x=0; x<w; x++){
92  int v = (*a++ + *c++) - 2 * *b++;
93  ret += FFABS(v);
94  }
95 
96  return ret;
97 }
98 
99 int ff_idet_filter_line_c_16bit(const uint16_t *a, const uint16_t *b, const uint16_t *c, int w)
100 {
101  int x;
102  int ret=0;
103 
104  for(x=0; x<w; x++){
105  int v = (*a++ + *c++) - 2 * *b++;
106  ret += FFABS(v);
107  }
108 
109  return ret;
110 }
111 
113 {
114  IDETContext *idet = ctx->priv;
115  int y, i;
116  int64_t alpha[2]={0};
117  int64_t delta=0;
118  int64_t gamma[2]={0};
119  Type type, best_type;
120  RepeatedField repeat;
121  int match = 0;
122  AVDictionary **metadata = &idet->cur->metadata;
123 
124  for (i = 0; i < idet->csp->nb_components; i++) {
125  int w = idet->cur->width;
126  int h = idet->cur->height;
127  int refs = idet->cur->linesize[i];
128 
129  if (i && i<3) {
130  w = AV_CEIL_RSHIFT(w, idet->csp->log2_chroma_w);
131  h = AV_CEIL_RSHIFT(h, idet->csp->log2_chroma_h);
132  }
133 
134  for (y = 2; y < h - 2; y++) {
135  uint8_t *prev = &idet->prev->data[i][y*refs];
136  uint8_t *cur = &idet->cur ->data[i][y*refs];
137  uint8_t *next = &idet->next->data[i][y*refs];
138  alpha[ y &1] += idet->filter_line(cur-refs, prev, cur+refs, w);
139  alpha[(y^1)&1] += idet->filter_line(cur-refs, next, cur+refs, w);
140  delta += idet->filter_line(cur-refs, cur, cur+refs, w);
141  gamma[(y^1)&1] += idet->filter_line(cur , prev, cur , w);
142  }
143  }
144 
145  if (alpha[0] > idet->interlace_threshold * alpha[1]){
146  type = TFF;
147  }else if(alpha[1] > idet->interlace_threshold * alpha[0]){
148  type = BFF;
149  }else if(alpha[1] > idet->progressive_threshold * delta){
150  type = PROGRESSIVE;
151  }else{
152  type = UNDETERMINED;
153  }
154 
155  if ( gamma[0] > idet->repeat_threshold * gamma[1] ){
156  repeat = REPEAT_TOP;
157  } else if ( gamma[1] > idet->repeat_threshold * gamma[0] ){
158  repeat = REPEAT_BOTTOM;
159  } else {
160  repeat = REPEAT_NONE;
161  }
162 
163  memmove(idet->history+1, idet->history, HIST_SIZE-1);
164  idet->history[0] = type;
165  best_type = UNDETERMINED;
166  for(i=0; i<HIST_SIZE; i++){
167  if(idet->history[i] != UNDETERMINED){
168  if(best_type == UNDETERMINED)
169  best_type = idet->history[i];
170 
171  if(idet->history[i] == best_type) {
172  match++;
173  }else{
174  match=0;
175  break;
176  }
177  }
178  }
179  if(idet->last_type == UNDETERMINED){
180  if(match ) idet->last_type = best_type;
181  }else{
182  if(match>2) idet->last_type = best_type;
183  }
184 
185  if (idet->last_type == TFF){
186  idet->cur->top_field_first = 1;
187  idet->cur->interlaced_frame = 1;
188  }else if(idet->last_type == BFF){
189  idet->cur->top_field_first = 0;
190  idet->cur->interlaced_frame = 1;
191  }else if(idet->last_type == PROGRESSIVE){
192  idet->cur->interlaced_frame = 0;
193  }
194 
195  for(i=0; i<3; i++)
196  idet->repeats[i] = av_rescale(idet->repeats [i], idet->decay_coefficient, PRECISION);
197 
198  for(i=0; i<4; i++){
199  idet->prestat [i] = av_rescale(idet->prestat [i], idet->decay_coefficient, PRECISION);
200  idet->poststat[i] = av_rescale(idet->poststat[i], idet->decay_coefficient, PRECISION);
201  }
202 
203  idet->total_repeats [ repeat] ++;
204  idet->repeats [ repeat] += PRECISION;
205 
206  idet->total_prestat [ type] ++;
207  idet->prestat [ type] += PRECISION;
208 
209  idet->total_poststat[idet->last_type] ++;
210  idet->poststat [idet->last_type] += PRECISION;
211 
212  av_log(ctx, AV_LOG_DEBUG, "Repeated Field:%12s, Single frame:%12s, Multi frame:%12s\n",
213  rep2str(repeat), type2str(type), type2str(idet->last_type));
214 
215  av_dict_set (metadata, "lavfi.idet.repeated.current_frame", rep2str(repeat), 0);
216  av_dict_set_fxp(metadata, "lavfi.idet.repeated.neither", idet->repeats[REPEAT_NONE], 2, 0);
217  av_dict_set_fxp(metadata, "lavfi.idet.repeated.top", idet->repeats[REPEAT_TOP], 2, 0);
218  av_dict_set_fxp(metadata, "lavfi.idet.repeated.bottom", idet->repeats[REPEAT_BOTTOM], 2, 0);
219 
220  av_dict_set (metadata, "lavfi.idet.single.current_frame", type2str(type), 0);
221  av_dict_set_fxp(metadata, "lavfi.idet.single.tff", idet->prestat[TFF], 2 , 0);
222  av_dict_set_fxp(metadata, "lavfi.idet.single.bff", idet->prestat[BFF], 2, 0);
223  av_dict_set_fxp(metadata, "lavfi.idet.single.progressive", idet->prestat[PROGRESSIVE], 2, 0);
224  av_dict_set_fxp(metadata, "lavfi.idet.single.undetermined", idet->prestat[UNDETERMINED], 2, 0);
225 
226  av_dict_set (metadata, "lavfi.idet.multiple.current_frame", type2str(idet->last_type), 0);
227  av_dict_set_fxp(metadata, "lavfi.idet.multiple.tff", idet->poststat[TFF], 2, 0);
228  av_dict_set_fxp(metadata, "lavfi.idet.multiple.bff", idet->poststat[BFF], 2, 0);
229  av_dict_set_fxp(metadata, "lavfi.idet.multiple.progressive", idet->poststat[PROGRESSIVE], 2, 0);
230  av_dict_set_fxp(metadata, "lavfi.idet.multiple.undetermined", idet->poststat[UNDETERMINED], 2, 0);
231 }
232 
233 static int filter_frame(AVFilterLink *link, AVFrame *picref)
234 {
235  AVFilterContext *ctx = link->dst;
236  IDETContext *idet = ctx->priv;
237 
238  // initial frame(s) and not interlaced, just pass through for
239  // the analyze_interlaced_flag mode
240  if (idet->analyze_interlaced_flag &&
241  !picref->interlaced_frame &&
242  !idet->next) {
243  return ff_filter_frame(ctx->outputs[0], picref);
244  }
245  if (idet->analyze_interlaced_flag_done) {
246  if (picref->interlaced_frame && idet->interlaced_flag_accuracy < 0)
247  picref->interlaced_frame = 0;
248  return ff_filter_frame(ctx->outputs[0], picref);
249  }
250 
251  av_frame_free(&idet->prev);
252 
253  if( picref->width != link->w
254  || picref->height != link->h
255  || picref->format != link->format) {
256  link->dst->inputs[0]->format = picref->format;
257  link->dst->inputs[0]->w = picref->width;
258  link->dst->inputs[0]->h = picref->height;
259 
260  av_frame_free(&idet->cur );
261  av_frame_free(&idet->next);
262  }
263 
264  idet->prev = idet->cur;
265  idet->cur = idet->next;
266  idet->next = picref;
267 
268  if (!idet->cur &&
269  !(idet->cur = av_frame_clone(idet->next)))
270  return AVERROR(ENOMEM);
271 
272  if (!idet->prev)
273  return 0;
274 
275  if (!idet->csp)
277  if (idet->csp->comp[0].depth > 8){
279 #if ARCH_X86
280  ff_idet_init_x86(idet, 1);
281 #endif
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 
340  av_log(ctx, AV_LOG_INFO, "Repeated Fields: Neither:%6"PRId64" Top:%6"PRId64" Bottom:%6"PRId64"\n",
341  idet->total_repeats[REPEAT_NONE],
342  idet->total_repeats[REPEAT_TOP],
344  );
345  av_log(ctx, AV_LOG_INFO, "Single frame detection: TFF:%6"PRId64" BFF:%6"PRId64" Progressive:%6"PRId64" Undetermined:%6"PRId64"\n",
346  idet->total_prestat[TFF],
347  idet->total_prestat[BFF],
348  idet->total_prestat[PROGRESSIVE],
350  );
351  av_log(ctx, AV_LOG_INFO, "Multi frame detection: TFF:%6"PRId64" BFF:%6"PRId64" Progressive:%6"PRId64" Undetermined:%6"PRId64"\n",
352  idet->total_poststat[TFF],
353  idet->total_poststat[BFF],
356  );
357 
358  av_frame_free(&idet->prev);
359  av_frame_free(&idet->cur );
360  av_frame_free(&idet->next);
361 }
362 
363 static const enum AVPixelFormat pix_fmts[] = {
395 };
396 
398 {
399  IDETContext *idet = ctx->priv;
400 
401  idet->eof = 0;
402  idet->last_type = UNDETERMINED;
403  memset(idet->history, UNDETERMINED, HIST_SIZE);
404 
405  if( idet->half_life > 0 )
406  idet->decay_coefficient = lrint( PRECISION * exp2(-1.0 / idet->half_life) );
407  else
409 
411 
412 #if ARCH_X86
413  ff_idet_init_x86(idet, 0);
414 #endif
415 
416  return 0;
417 }
418 
419 static const AVFilterPad idet_inputs[] = {
420  {
421  .name = "default",
422  .type = AVMEDIA_TYPE_VIDEO,
423  .filter_frame = filter_frame,
424  },
425 };
426 
427 static const AVFilterPad idet_outputs[] = {
428  {
429  .name = "default",
430  .type = AVMEDIA_TYPE_VIDEO,
431  .request_frame = request_frame
432  },
433 };
434 
436  .name = "idet",
437  .description = NULL_IF_CONFIG_SMALL("Interlace detect Filter."),
438  .priv_size = sizeof(IDETContext),
439  .init = init,
440  .uninit = uninit,
445  .priv_class = &idet_class,
446 };
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
type2str
static const char * type2str(Type type)
Definition: vf_idet.c:42
r
const char * r
Definition: vf_curves.c:126
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_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:969
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
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
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:174
HIST_SIZE
#define HIST_SIZE
Definition: f_ebur128.c:49
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:99
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
AVFrame::width
int width
Definition: frame.h:402
w
uint8_t w
Definition: llviddspenc.c:38
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:491
AVOption
AVOption.
Definition: opt.h:251
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:233
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:459
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:415
float.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_idet.c:363
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:32
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:165
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
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:99
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:457
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:443
IDETContext::interlace_threshold
float interlace_threshold
Definition: vf_idet.h:44
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:462
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
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:471
IDETContext::next
AVFrame * next
Definition: vf_idet.h:62
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:472
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
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:62
FLAGS
#define FLAGS
Definition: vf_idet.c:29
idet_outputs
static const AVFilterPad idet_outputs[]
Definition: vf_idet.c:427
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:456
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:470
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:465
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_idet.c:397
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
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:174
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:194
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:64
idet_options
static const AVOption idet_options[]
Definition: vf_idet.c:31
ff_vf_idet
const AVFilter ff_vf_idet
Definition: vf_idet.c:435
NULL
#define NULL
Definition: coverity.c:32
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
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:419
OFFSET
#define OFFSET(x)
Definition: vf_idet.c:28
uintpow
static uint64_t uintpow(uint64_t b, unsigned int e)
Definition: vf_idet.c:55
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:460
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:115
filter
static void filter(AVFilterContext *ctx)
Definition: vf_idet.c:112
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:464
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:466
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:417
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:191
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:486
Type
Type
Definition: vf_idet.h:29
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
rep2str
static const char * rep2str(RepeatedField repeated_field)
Definition: vf_idet.c:76
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:55
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:458
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:161
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:463
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:468
PRECISION
#define PRECISION
Definition: vf_idet.c:53
IDETContext::history
uint8_t history[HIST_SIZE]
Definition: vf_idet.h:59
AVFrame::height
int height
Definition: frame.h:402
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:639
IDETContext::repeats
uint64_t repeats[3]
Definition: vf_idet.h:52
AVFILTER_FLAG_METADATA_ONLY
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
Definition: avfilter.h:133
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
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:392
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:86
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
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:195
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:86
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, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:375
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:27
h
h
Definition: vp9dsp_template.c:2038
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:469
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:63
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:467