FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
f_select.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
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 /**
22  * @file
23  * filter for selecting which frame passes in the filterchain
24  */
25 
26 #include "config_components.h"
27 
28 #include "libavutil/avstring.h"
29 #include "libavutil/eval.h"
30 #include "libavutil/fifo.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 #include "avfilter.h"
36 #include "audio.h"
37 #include "filters.h"
38 #include "formats.h"
39 #include "video.h"
40 #include "scene_sad.h"
41 
42 static const char *const var_names[] = {
43  "TB", ///< timebase
44 
45  "pts", ///< original pts in the file of the frame
46  "start_pts", ///< first PTS in the stream, expressed in TB units
47  "prev_pts", ///< previous frame PTS
48  "prev_selected_pts", ///< previous selected frame PTS
49 
50  "t", ///< timestamp expressed in seconds
51  "start_t", ///< first PTS in the stream, expressed in seconds
52  "prev_t", ///< previous frame time
53  "prev_selected_t", ///< previously selected time
54 
55  "pict_type", ///< the type of picture in the movie
56  "I",
57  "P",
58  "B",
59  "S",
60  "SI",
61  "SP",
62  "BI",
63  "PICT_TYPE_I",
64  "PICT_TYPE_P",
65  "PICT_TYPE_B",
66  "PICT_TYPE_S",
67  "PICT_TYPE_SI",
68  "PICT_TYPE_SP",
69  "PICT_TYPE_BI",
70 
71  "interlace_type", ///< the frame interlace type
72  "PROGRESSIVE",
73  "TOPFIRST",
74  "BOTTOMFIRST",
75 
76  "consumed_samples_n",///< number of samples consumed by the filter (only audio)
77  "samples_n", ///< number of samples in the current frame (only audio)
78  "sample_rate", ///< sample rate (only audio)
79 
80  "n", ///< frame number (starting from zero)
81  "selected_n", ///< selected frame number (starting from zero)
82  "prev_selected_n", ///< number of the last selected frame
83 
84  "key", ///< tell if the frame is a key frame
85 
86  "scene",
87 
88  "concatdec_select", ///< frame is within the interval set by the concat demuxer
89 
90  "ih", ///< ih: Represents the height of the input video frame.
91  "iw", ///< iw: Represents the width of the input video frame.
92 
93  "view",
94 
95  NULL
96 };
97 
98 enum var_name {
100 
105 
110 
126 
131 
135 
139 
141 
143 
145 
148 
150 
152 };
153 
154 typedef struct SelectContext {
155  const AVClass *class;
156  char *expr_str;
159  int bitdepth;
161  ptrdiff_t width[4];
162  ptrdiff_t height[4];
163  int do_scene_detect; ///< 1 if the expression requires scene detection variables, 0 otherwise
164  ff_scene_sad_fn sad; ///< Sum of the absolute difference function (scene detect only)
165  double prev_mafd; ///< previous MAFD (scene detect only)
166  AVFrame *prev_picref; ///< previous frame (scene detect only)
167  double select;
168  int select_out; ///< mark the selected output pad index
170 } SelectContext;
171 
172 #define OFFSET(x) offsetof(SelectContext, x)
173 #define DEFINE_OPTIONS(filt_name, FLAGS) \
174 static const AVOption filt_name##_options[] = { \
175  { "expr", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \
176  { "e", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \
177  { "outputs", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \
178  { "n", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \
179  { NULL } \
180 }
181 
183 {
184  SelectContext *select = ctx->priv;
185  int i, ret;
186 
187  if ((ret = av_expr_parse(&select->expr, select->expr_str,
188  var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
189  av_log(ctx, AV_LOG_ERROR, "Error while parsing expression '%s'\n",
190  select->expr_str);
191  return ret;
192  }
193  select->do_scene_detect = !!strstr(select->expr_str, "scene");
194 
195  for (i = 0; i < select->nb_outputs; i++) {
196  AVFilterPad pad = { 0 };
197 
198  pad.name = av_asprintf("output%d", i);
199  if (!pad.name)
200  return AVERROR(ENOMEM);
201  pad.type = ctx->filter->inputs[0].type;
202  if ((ret = ff_append_outpad_free_name(ctx, &pad)) < 0)
203  return ret;
204  }
205 
206  return 0;
207 }
208 
209 #define INTERLACE_TYPE_P 0
210 #define INTERLACE_TYPE_T 1
211 #define INTERLACE_TYPE_B 2
212 
214 {
215  SelectContext *select = inlink->dst->priv;
217  int is_yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) &&
218  (desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
219  desc->nb_components >= 3;
220 
221  select->bitdepth = desc->comp[0].depth;
222  select->nb_planes = is_yuv ? 1 : av_pix_fmt_count_planes(inlink->format);
223 
224  for (int plane = 0; plane < select->nb_planes; plane++) {
225  ptrdiff_t line_size = av_image_get_linesize(inlink->format, inlink->w, plane);
226  int vsub = desc->log2_chroma_h;
227 
228  select->width[plane] = line_size >> (select->bitdepth > 8);
229  select->height[plane] = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
230  }
231 
232  select->var_values[VAR_N] = 0.0;
233  select->var_values[VAR_SELECTED_N] = 0.0;
234 
235  select->var_values[VAR_TB] = av_q2d(inlink->time_base);
236 
238  select->var_values[VAR_PREV_PTS] = NAN;
241  select->var_values[VAR_PREV_T] = NAN;
242  select->var_values[VAR_START_PTS] = NAN;
243  select->var_values[VAR_START_T] = NAN;
244 
257 
261 
262  select->var_values[VAR_PICT_TYPE] = NAN;
263  select->var_values[VAR_INTERLACE_TYPE] = NAN;
264  select->var_values[VAR_SCENE] = NAN;
266  select->var_values[VAR_SAMPLES_N] = NAN;
267 
268  select->var_values[VAR_IH] = NAN;
269  select->var_values[VAR_IW] = NAN;
270 
271  select->var_values[VAR_SAMPLE_RATE] =
272  inlink->type == AVMEDIA_TYPE_AUDIO ? inlink->sample_rate : NAN;
273 
274  if (CONFIG_SELECT_FILTER && select->do_scene_detect) {
275  select->sad = ff_scene_sad_get_fn(select->bitdepth);
276  if (!select->sad)
277  return AVERROR(EINVAL);
278  }
279  return 0;
280 }
281 
283 {
284  double ret = 0;
285  SelectContext *select = ctx->priv;
286  AVFrame *prev_picref = select->prev_picref;
287 
288  if (prev_picref &&
289  frame->height == prev_picref->height &&
290  frame->width == prev_picref->width) {
291  uint64_t sad = 0;
292  double mafd, diff;
293  uint64_t count = 0;
294 
295  for (int plane = 0; plane < select->nb_planes; plane++) {
296  uint64_t plane_sad;
297  select->sad(prev_picref->data[plane], prev_picref->linesize[plane],
298  frame->data[plane], frame->linesize[plane],
299  select->width[plane], select->height[plane], &plane_sad);
300  sad += plane_sad;
301  count += select->width[plane] * select->height[plane];
302  }
303 
304  mafd = (double)sad / count / (1ULL << (select->bitdepth - 8));
305  diff = fabs(mafd - select->prev_mafd);
306  ret = av_clipf(FFMIN(mafd, diff) / 100., 0, 1);
307  select->prev_mafd = mafd;
308  av_frame_free(&prev_picref);
309  }
310  select->prev_picref = av_frame_clone(frame);
311  return ret;
312 }
313 
315 {
316  AVDictionary *metadata = frame->metadata;
317  AVDictionaryEntry *start_time_entry = av_dict_get(metadata, "lavf.concatdec.start_time", NULL, 0);
318  AVDictionaryEntry *duration_entry = av_dict_get(metadata, "lavf.concatdec.duration", NULL, 0);
319  if (start_time_entry) {
320  int64_t start_time = strtoll(start_time_entry->value, NULL, 10);
321  if (pts >= start_time) {
322  if (duration_entry) {
323  int64_t duration = strtoll(duration_entry->value, NULL, 10);
324  if (pts < start_time + duration)
325  return -1;
326  else
327  return 0;
328  }
329  return -1;
330  }
331  return 0;
332  }
333  return NAN;
334 }
335 
337 {
338  SelectContext *select = ctx->priv;
339  AVFilterLink *inlink = ctx->inputs[0];
341  const AVFrameSideData *sd;
342  double res;
343 
344  if (isnan(select->var_values[VAR_START_PTS]))
345  select->var_values[VAR_START_PTS] = TS2D(frame->pts);
346  if (isnan(select->var_values[VAR_START_T]))
347  select->var_values[VAR_START_T] = TS2D(frame->pts) * av_q2d(inlink->time_base);
348 
349  select->var_values[VAR_N ] = inl->frame_count_out - 1;
350  select->var_values[VAR_PTS] = TS2D(frame->pts);
351  select->var_values[VAR_T ] = TS2D(frame->pts) * av_q2d(inlink->time_base);
352  select->var_values[VAR_KEY] = !!(frame->flags & AV_FRAME_FLAG_KEY);
354 
355  switch (inlink->type) {
356  case AVMEDIA_TYPE_AUDIO:
357  select->var_values[VAR_SAMPLES_N] = frame->nb_samples;
358  break;
359 
360  case AVMEDIA_TYPE_VIDEO:
361  select->var_values[VAR_IH] = frame->height;
362  select->var_values[VAR_IW] = frame->width;
363 
364  select->var_values[VAR_INTERLACE_TYPE] =
367  select->var_values[VAR_PICT_TYPE] = frame->pict_type;
368  if (select->do_scene_detect) {
369  char buf[32];
371  // TODO: document metadata
372  snprintf(buf, sizeof(buf), "%f", select->var_values[VAR_SCENE]);
373  av_dict_set(&frame->metadata, "lavfi.scene_score", buf, 0);
374  }
375 
376  sd = av_frame_side_data_get(frame->side_data, frame->nb_side_data,
378  select->var_values[VAR_VIEW] = sd ? *(int*)sd->data : NAN;
379  break;
380  }
381 
382  select->select = res = av_expr_eval(select->expr, select->var_values, NULL);
383  av_log(inlink->dst, AV_LOG_DEBUG,
384  "n:%f pts:%f t:%f key:%d",
385  select->var_values[VAR_N],
386  select->var_values[VAR_PTS],
387  select->var_values[VAR_T],
388  !!(frame->flags & AV_FRAME_FLAG_KEY));
389 
390  switch (inlink->type) {
391  case AVMEDIA_TYPE_VIDEO:
392  av_log(inlink->dst, AV_LOG_DEBUG, " interlace_type:%c pict_type:%c scene:%f",
393  !(frame->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' :
394  (frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B',
395  av_get_picture_type_char(frame->pict_type),
396  select->var_values[VAR_SCENE]);
397  break;
398  case AVMEDIA_TYPE_AUDIO:
399  av_log(inlink->dst, AV_LOG_DEBUG, " samples_n:%d consumed_samples_n:%f",
400  frame->nb_samples,
402  break;
403  }
404 
405  if (res == 0) {
406  select->select_out = -1; /* drop */
407  } else if (isnan(res) || res < 0) {
408  select->select_out = 0; /* first output */
409  } else {
410  select->select_out = FFMIN(ceilf(res)-1, select->nb_outputs-1); /* other outputs */
411  }
412 
413  av_log(inlink->dst, AV_LOG_DEBUG, " -> select:%f select_out:%d\n", res, select->select_out);
414 
415  if (res) {
416  select->var_values[VAR_PREV_SELECTED_N] = select->var_values[VAR_N];
418  select->var_values[VAR_PREV_SELECTED_T] = select->var_values[VAR_T];
419  select->var_values[VAR_SELECTED_N] += 1.0;
420  if (inlink->type == AVMEDIA_TYPE_AUDIO)
421  select->var_values[VAR_CONSUMED_SAMPLES_N] += frame->nb_samples;
422  }
423 
424  select->var_values[VAR_PREV_PTS] = select->var_values[VAR_PTS];
425  select->var_values[VAR_PREV_T] = select->var_values[VAR_T];
426 }
427 
429 {
430  SelectContext *select = ctx->priv;
431  AVFilterLink *inlink = ctx->inputs[0];
432  AVFrame *in;
433  int nb_eofs = 0;
434  int ret;
435 
436  for (int i = 0; i < ctx->nb_outputs; i++)
437  nb_eofs += ff_outlink_get_status(ctx->outputs[i]) == AVERROR_EOF;
438 
439  if (nb_eofs == ctx->nb_outputs) {
441  return 0;
442  }
443 
444  while ((ret = ff_inlink_consume_frame(inlink, &in))) {
445  if (ret < 0)
446  return ret;
447  select_frame(ctx, in);
448  if (select->select && !ff_outlink_get_status(ctx->outputs[select->select_out]))
449  return ff_filter_frame(ctx->outputs[select->select_out], in);
450  av_frame_free(&in);
451  };
452 
455 
456  return FFERROR_NOT_READY;
457 }
458 
460 {
461  SelectContext *select = ctx->priv;
462 
463  av_expr_free(select->expr);
464  select->expr = NULL;
465 
466  if (select->do_scene_detect) {
467  av_frame_free(&select->prev_picref);
468  }
469 }
470 
471 #if CONFIG_ASELECT_FILTER
472 
474 AVFILTER_DEFINE_CLASS(aselect);
475 
476 static av_cold int aselect_init(AVFilterContext *ctx)
477 {
478  SelectContext *select = ctx->priv;
479  int ret;
480 
481  if ((ret = init(ctx)) < 0)
482  return ret;
483 
484  if (select->do_scene_detect) {
485  av_log(ctx, AV_LOG_ERROR, "Scene detection is ignored in aselect filter\n");
486  return AVERROR(EINVAL);
487  }
488 
489  return 0;
490 }
491 
492 static const AVFilterPad avfilter_af_aselect_inputs[] = {
493  {
494  .name = "default",
495  .type = AVMEDIA_TYPE_AUDIO,
496  .config_props = config_input,
497  },
498 };
499 
500 const FFFilter ff_af_aselect = {
501  .p.name = "aselect",
502  .p.description = NULL_IF_CONFIG_SMALL("Select audio frames to pass in output."),
503  .p.priv_class = &aselect_class,
505  .init = aselect_init,
506  .uninit = uninit,
507  .priv_size = sizeof(SelectContext),
508  FILTER_INPUTS(avfilter_af_aselect_inputs),
509 };
510 #endif /* CONFIG_ASELECT_FILTER */
511 
512 #if CONFIG_SELECT_FILTER
513 
514 static int query_formats(const AVFilterContext *ctx,
515  AVFilterFormatsConfig **cfg_in,
516  AVFilterFormatsConfig **cfg_out)
517 {
518  const SelectContext *select = ctx->priv;
519 
520  if (select->do_scene_detect) {
521  static const enum AVPixelFormat pix_fmts[] = {
528  };
529  return ff_set_common_formats_from_list2(ctx, cfg_in, cfg_out, pix_fmts);
530  }
531  return 0;
532 }
533 
535 AVFILTER_DEFINE_CLASS(select);
536 
537 static av_cold int select_init(AVFilterContext *ctx)
538 {
539  int ret;
540 
541  if ((ret = init(ctx)) < 0)
542  return ret;
543 
544  return 0;
545 }
546 
547 static const AVFilterPad avfilter_vf_select_inputs[] = {
548  {
549  .name = "default",
550  .type = AVMEDIA_TYPE_VIDEO,
551  .config_props = config_input,
552  },
553 };
554 
555 const FFFilter ff_vf_select = {
556  .p.name = "select",
557  .p.description = NULL_IF_CONFIG_SMALL("Select video frames to pass in output."),
558  .p.priv_class = &select_class,
560  .init = select_init,
561  .uninit = uninit,
562  .activate = activate,
563  .priv_size = sizeof(SelectContext),
564  FILTER_INPUTS(avfilter_vf_select_inputs),
566 };
567 #endif /* CONFIG_SELECT_FILTER */
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
VAR_PICT_TYPE_S
@ VAR_PICT_TYPE_S
Definition: f_select.c:122
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
VAR_INTERLACE_TYPE_P
@ VAR_INTERLACE_TYPE_P
Definition: f_select.c:128
var_name
var_name
Definition: noise.c:47
VAR_P
@ VAR_P
Definition: f_select.c:113
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3441
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:263
SelectContext
Definition: f_select.c:154
int64_t
long long int64_t
Definition: coverity.c:34
metadata
Stream codec metadata
Definition: ogg-flac-chained-meta.txt:2
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:63
VAR_PREV_T
@ VAR_PREV_T
Definition: f_select.c:108
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:263
ff_vf_select
const FFFilter ff_vf_select
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
get_concatdec_select
static double get_concatdec_select(AVFrame *frame, int64_t pts)
Definition: f_select.c:314
pixdesc.h
AVFrame::width
int width
Definition: frame.h:493
VAR_INTERLACE_TYPE_B
@ VAR_INTERLACE_TYPE_B
Definition: f_select.c:130
VAR_T
@ VAR_T
Definition: f_select.c:106
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: f_select.c:459
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
VAR_START_T
@ VAR_START_T
Definition: f_select.c:107
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
AVDictionary
Definition: dict.c:32
VAR_SAMPLE_RATE
@ VAR_SAMPLE_RATE
Definition: f_select.c:134
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:215
SelectContext::sad
ff_scene_sad_fn sad
Sum of the absolute difference function (scene detect only)
Definition: f_select.c:164
video.h
VAR_SCENE
@ VAR_SCENE
Definition: f_select.c:142
VAR_CONSUMED_SAMPLES_N
@ VAR_CONSUMED_SAMPLES_N
Definition: f_select.c:132
ceilf
static __device__ float ceilf(float a)
Definition: cuda_runtime.h:175
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:442
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:649
formats.h
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:710
VAR_PREV_SELECTED_N
@ VAR_PREV_SELECTED_N
Definition: f_select.c:138
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1510
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3481
fifo.h
VAR_SAMPLES_N
@ VAR_SAMPLES_N
Definition: f_select.c:133
VAR_START_PTS
@ VAR_START_PTS
Definition: f_select.c:102
VAR_PICT_TYPE_P
@ VAR_PICT_TYPE_P
Definition: f_select.c:120
pts
static int64_t pts
Definition: transcode_aac.c:644
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:357
VAR_BI
@ VAR_BI
Definition: f_select.c:118
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
SelectContext::width
ptrdiff_t width[4]
Definition: f_select.c:161
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:636
FFFilter
Definition: filters.h:266
duration
int64_t duration
Definition: movenc.c:65
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
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:86
get_scene_score
static double get_scene_score(AVFilterContext *ctx, AVFrame *frame)
Definition: f_select.c:282
INTERLACE_TYPE_T
#define INTERLACE_TYPE_T
Definition: f_select.c:210
VAR_SI
@ VAR_SI
Definition: f_select.c:116
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
VAR_PREV_SELECTED_PTS
@ VAR_PREV_SELECTED_PTS
Definition: f_select.c:104
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
VAR_PICT_TYPE
@ VAR_PICT_TYPE
Definition: f_select.c:111
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:298
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:481
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVExpr
Definition: eval.c:158
SelectContext::select_out
int select_out
mark the selected output pad index
Definition: f_select.c:168
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
VAR_IW
@ VAR_IW
Definition: f_select.c:147
VAR_PREV_SELECTED_T
@ VAR_PREV_SELECTED_T
Definition: f_select.c:109
NAN
#define NAN
Definition: mathematics.h:115
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
INTERLACE_TYPE_B
#define INTERLACE_TYPE_B
Definition: f_select.c:211
VAR_N
@ VAR_N
Definition: f_select.c:136
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
isnan
#define isnan(x)
Definition: libm.h:342
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:85
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:282
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
SelectContext::select
double select
Definition: f_select.c:167
VAR_VIEW
@ VAR_VIEW
Definition: f_select.c:149
SelectContext::prev_picref
AVFrame * prev_picref
previous frame (scene detect only)
Definition: f_select.c:166
DEFINE_OPTIONS
#define DEFINE_OPTIONS(filt_name, FLAGS)
Definition: f_select.c:173
double
double
Definition: af_crystalizer.c:132
av_clipf
av_clipf
Definition: af_crystalizer.c:122
init
static av_cold int init(AVFilterContext *ctx)
Definition: f_select.c:182
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: filters.h:477
AV_PICTURE_TYPE_SP
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:283
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
SelectContext::prev_mafd
double prev_mafd
previous MAFD (scene detect only)
Definition: f_select.c:165
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:121
SelectContext::do_scene_detect
int do_scene_detect
1 if the expression requires scene detection variables, 0 otherwise
Definition: f_select.c:163
scene_sad.h
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:198
TS2D
#define TS2D(ts)
Definition: filters.h:481
FF_FILTER_FORWARD_WANTED_ANY
FF_FILTER_FORWARD_WANTED_ANY(filter, inlink)
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:157
config_input
static int config_input(AVFilterLink *inlink)
Definition: f_select.c:213
eval.h
AV_OPT_FLAG_FILTERING_PARAM
#define AV_OPT_FLAG_FILTERING_PARAM
A generic parameter which can be set by the user for filtering.
Definition: opt.h:381
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
ff_inlink_set_status
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
Definition: avfilter.c:1622
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:94
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
ff_af_aselect
const FFFilter ff_af_aselect
start_time
static int64_t start_time
Definition: ffplay.c:326
VAR_INTERLACE_TYPE
@ VAR_INTERLACE_TYPE
Definition: f_select.c:127
VAR_VARS_NB
@ VAR_VARS_NB
Definition: f_select.c:151
AVFrameSideData::data
uint8_t * data
Definition: frame.h:278
ff_scene_sad_fn
void(* ff_scene_sad_fn)(SCENE_SAD_PARAMS)
Definition: scene_sad.h:34
var_names
static const char *const var_names[]
Definition: f_select.c:42
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
SelectContext::expr
AVExpr * expr
Definition: f_select.c:157
VAR_IH
@ VAR_IH
Definition: f_select.c:146
AV_FRAME_DATA_VIEW_ID
@ AV_FRAME_DATA_VIEW_ID
This side data must be associated with a video frame.
Definition: frame.h:245
av_image_get_linesize
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane.
Definition: imgutils.c:76
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
VAR_TB
@ VAR_TB
Definition: f_select.c:99
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
SelectContext::expr_str
char * expr_str
Definition: f_select.c:156
activate
static int activate(AVFilterContext *ctx)
Definition: f_select.c:428
internal.h
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:240
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:358
SelectContext::nb_planes
int nb_planes
Definition: f_select.c:160
VAR_PICT_TYPE_SI
@ VAR_PICT_TYPE_SI
Definition: f_select.c:123
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
SelectContext::bitdepth
int bitdepth
Definition: f_select.c:159
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:644
select_frame
static void select_frame(AVFilterContext *ctx, AVFrame *frame)
Definition: f_select.c:336
VAR_B
@ VAR_B
Definition: f_select.c:114
VAR_PICT_TYPE_BI
@ VAR_PICT_TYPE_BI
Definition: f_select.c:125
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: filters.h:50
frame
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 the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
VAR_KEY
@ VAR_KEY
Definition: f_select.c:140
VAR_SELECTED_N
@ VAR_SELECTED_N
Definition: f_select.c:137
SelectContext::var_values
double var_values[VAR_VARS_NB]
Definition: f_select.c:158
SelectContext::nb_outputs
int nb_outputs
Definition: f_select.c:169
ff_scene_sad_get_fn
ff_scene_sad_fn ff_scene_sad_get_fn(int depth)
Definition: scene_sad.c:59
AVFrame::height
int height
Definition: frame.h:493
VAR_S
@ VAR_S
Definition: f_select.c:115
ff_set_common_formats_from_list2
int ff_set_common_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *fmts)
Definition: formats.c:1016
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:280
VAR_PICT_TYPE_I
@ VAR_PICT_TYPE_I
Definition: f_select.c:119
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
VAR_PREV_PTS
@ VAR_PREV_PTS
Definition: f_select.c:103
avfilter.h
VAR_SP
@ VAR_SP
Definition: f_select.c:117
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:178
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
VAR_PICT_TYPE_SP
@ VAR_PICT_TYPE_SP
Definition: f_select.c:124
ff_outlink_get_status
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1638
AVFilterContext
An instance of a filter.
Definition: avfilter.h:269
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
audio.h
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:276
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVDictionaryEntry
Definition: dict.h:90
VAR_PTS
@ VAR_PTS
Definition: f_select.c:101
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:143
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_PICTURE_TYPE_BI
@ AV_PICTURE_TYPE_BI
BI type.
Definition: avutil.h:284
FF_FILTER_FORWARD_STATUS_ALL
#define FF_FILTER_FORWARD_STATUS_ALL(inlink, filter)
Acknowledge the status on an input link and forward it to an output link.
Definition: filters.h:678
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1138
SelectContext::height
ptrdiff_t height[4]
Definition: f_select.c:162
imgutils.h
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:466
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVDictionaryEntry::value
char * value
Definition: dict.h:92
avstring.h
VAR_PICT_TYPE_B
@ VAR_PICT_TYPE_B
Definition: f_select.c:121
VAR_INTERLACE_TYPE_T
@ VAR_INTERLACE_TYPE_T
Definition: f_select.c:129
snprintf
#define snprintf
Definition: snprintf.h:34
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: aeval.c:246
VAR_I
@ VAR_I
Definition: f_select.c:112
VAR_CONCATDEC_SELECT
@ VAR_CONCATDEC_SELECT
Definition: f_select.c:144
INTERLACE_TYPE_P
#define INTERLACE_TYPE_P
Definition: f_select.c:209