FFmpeg: libavfilter/vf_idet.c Source File

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 
40 AVFILTER_DEFINE_CLASS(idet);
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 
112  static void filter(AVFilterContext *ctx)
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)
276  idet->csp = av_pix_fmt_desc_get(link->format);
277  if (idet->csp->comp[0].depth > 8){
278  idet->filter_line = (ff_idet_filter_func)ff_idet_filter_line_c_16bit;
279  if (ARCH_X86)
280  ff_idet_init_x86(idet, 1);
281  }
282 
283  if (idet->analyze_interlaced_flag) {
284  if (idet->cur->interlaced_frame) {
285  idet->cur->interlaced_frame = 0;
286  filter(ctx);
287  if (idet->last_type == PROGRESSIVE) {
288  idet->interlaced_flag_accuracy --;
289  idet->analyze_interlaced_flag --;
290  } else if (idet->last_type != UNDETERMINED) {
291  idet->interlaced_flag_accuracy ++;
292  idet->analyze_interlaced_flag --;
293  }
294  if (idet->analyze_interlaced_flag == 1) {
295  ff_filter_frame(ctx->outputs[0], av_frame_clone(idet->cur));
296 
297  if (idet->next->interlaced_frame && idet->interlaced_flag_accuracy < 0)
298  idet->next->interlaced_frame = 0;
299  idet->analyze_interlaced_flag_done = 1;
300  av_log(ctx, AV_LOG_INFO, "Final flag accuracy %d\n", idet->interlaced_flag_accuracy);
301  return ff_filter_frame(ctx->outputs[0], av_frame_clone(idet->next));
302  }
303  }
304  } else {
305  filter(ctx);
306  }
307 
308  return ff_filter_frame(ctx->outputs[0], av_frame_clone(idet->cur));
309 }
310 
311  static int request_frame(AVFilterLink *link)
312 {
313  AVFilterContext *ctx = link->src;
314  IDETContext *idet = ctx->priv;
315  int ret;
316 
317  if (idet->eof)
318  return AVERROR_EOF;
319 
320  ret = ff_request_frame(link->src->inputs[0]);
321 
322  if (ret == AVERROR_EOF && idet->cur && !idet->analyze_interlaced_flag_done) {
323  AVFrame *next = av_frame_clone(idet->next);
324 
325  if (!next)
326  return AVERROR(ENOMEM);
327 
328  ret = filter_frame(link->src->inputs[0], next);
329  idet->eof = 1;
330  }
331 
332  return ret;
333 }
334 
335  static av_cold void uninit(AVFilterContext *ctx)
336 {
337  IDETContext *idet = ctx->priv;
338 
339  av_log(ctx, AV_LOG_INFO, "Repeated Fields: Neither:%6"PRId64" Top:%6"PRId64" Bottom:%6"PRId64"\n",
340  idet->total_repeats[REPEAT_NONE],
341  idet->total_repeats[REPEAT_TOP],
342  idet->total_repeats[REPEAT_BOTTOM]
343  );
344  av_log(ctx, AV_LOG_INFO, "Single frame detection: TFF:%6"PRId64" BFF:%6"PRId64" Progressive:%6"PRId64" Undetermined:%6"PRId64"\n",
345  idet->total_prestat[TFF],
346  idet->total_prestat[BFF],
347  idet->total_prestat[PROGRESSIVE],
348  idet->total_prestat[UNDETERMINED]
349  );
350  av_log(ctx, AV_LOG_INFO, "Multi frame detection: TFF:%6"PRId64" BFF:%6"PRId64" Progressive:%6"PRId64" Undetermined:%6"PRId64"\n",
351  idet->total_poststat[TFF],
352  idet->total_poststat[BFF],
353  idet->total_poststat[PROGRESSIVE],
354  idet->total_poststat[UNDETERMINED]
355  );
356 
357  av_frame_free(&idet->prev);
358  av_frame_free(&idet->cur );
359  av_frame_free(&idet->next);
360 }
361 
362  static const enum AVPixelFormat pix_fmts[] = {
363  AV_PIX_FMT_YUV420P,
364  AV_PIX_FMT_YUV422P,
365  AV_PIX_FMT_YUV444P,
366  AV_PIX_FMT_YUV410P,
367  AV_PIX_FMT_YUV411P,
368  AV_PIX_FMT_GRAY8,
369  AV_PIX_FMT_YUVJ420P,
370  AV_PIX_FMT_YUVJ422P,
371  AV_PIX_FMT_YUVJ444P,
372  AV_PIX_FMT_GRAY16,
373  AV_PIX_FMT_YUV440P,
374  AV_PIX_FMT_YUVJ440P,
375  AV_PIX_FMT_YUV420P9,
376  AV_PIX_FMT_YUV422P9,
377  AV_PIX_FMT_YUV444P9,
378  AV_PIX_FMT_YUV420P10,
379  AV_PIX_FMT_YUV422P10,
380  AV_PIX_FMT_YUV444P10,
381  AV_PIX_FMT_YUV420P12,
382  AV_PIX_FMT_YUV422P12,
383  AV_PIX_FMT_YUV444P12,
384  AV_PIX_FMT_YUV420P14,
385  AV_PIX_FMT_YUV422P14,
386  AV_PIX_FMT_YUV444P14,
387  AV_PIX_FMT_YUV420P16,
388  AV_PIX_FMT_YUV422P16,
389  AV_PIX_FMT_YUV444P16,
390  AV_PIX_FMT_YUVA420P,
391  AV_PIX_FMT_YUVA422P,
392  AV_PIX_FMT_YUVA444P,
393  AV_PIX_FMT_NONE
394 };
395 
396  static av_cold int init(AVFilterContext *ctx)
397 {
398  IDETContext *idet = ctx->priv;
399 
400  idet->eof = 0;
401  idet->last_type = UNDETERMINED;
402  memset(idet->history, UNDETERMINED, HIST_SIZE);
403 
404  if( idet->half_life > 0 )
405  idet->decay_coefficient = lrint( PRECISION * exp2(-1.0 / idet->half_life) );
406  else
407  idet->decay_coefficient = PRECISION;
408 
409  idet->filter_line = ff_idet_filter_line_c;
410 
411  if (ARCH_X86)
412  ff_idet_init_x86(idet, 0);
413 
414  return 0;
415 }
416 
417  static const AVFilterPad idet_inputs[] = {
418  {
419  .name = "default",
420  .type = AVMEDIA_TYPE_VIDEO,
421  .filter_frame = filter_frame,
422  },
423 };
424 
425  static const AVFilterPad idet_outputs[] = {
426  {
427  .name = "default",
428  .type = AVMEDIA_TYPE_VIDEO,
429  .request_frame = request_frame
430  },
431 };
432 
433  const AVFilter ff_vf_idet = {
434  .name = "idet",
435  .description = NULL_IF_CONFIG_SMALL("Interlace detect Filter."),
436  .priv_size = sizeof(IDETContext),
437  .init = init,
438  .uninit = uninit,
439  .flags = AVFILTER_FLAG_METADATA_ONLY,
440  FILTER_INPUTS(idet_inputs),
441  FILTER_OUTPUTS(idet_outputs),
442  FILTER_PIXFMTS_ARRAY(pix_fmts),
443  .priv_class = &idet_class,
444 };
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: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:311
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:1018
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
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:171
HIST_SIZE
#define HIST_SIZE
Definition: f_ebur128.c:50
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
AVFrame::width
int width
Definition: frame.h:389
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:474
AVOption
AVOption.
Definition: opt.h:247
b
#define b
Definition: input.c:40
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:404
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:420
float.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_idet.c:362
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:169
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
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:402
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:388
IDETContext::interlace_threshold
float interlace_threshold
Definition: vf_idet.h:44
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:407
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:416
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:417
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
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:425
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:401
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:415
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:422
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_idet.c:396
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:168
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:191
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:65
idet_options
static const AVOption idet_options[]
Definition: vf_idet.c:31
ff_vf_idet
const AVFilter ff_vf_idet
Definition: vf_idet.c:433
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:417
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:405
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
filter
static void filter(AVFilterContext *ctx)
Definition: vf_idet.c:112
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_idet.c:335
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:409
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:411
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:404
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:227
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:469
Type
Type
Definition: vf_idet.h:29
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:56
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:128
IDETContext::cur
AVFrame * cur
Definition: vf_idet.h:61
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:403
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:165
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:408
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:413
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:389
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:608
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:137
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:402
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:192
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, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:362
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:414
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:68
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:412
Generated on Wed Aug 24 2022 21:38:14 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /